Untabify C files. Will watch buildbots.

54 files changed, 25074 insertions, 25074 deletions

diff --git a/Python/asdl.c b/Python/asdl.c
index 1105d3a..c30d7d20 100644
--- a/Python/asdl.c
+++ b/Python/asdl.c
@@ -4,61 +4,61 @@
 asdl_seq *
 asdl_seq_new(int size, PyArena *arena)
 {
-	asdl_seq *seq = NULL;
-	size_t n = (size ? (sizeof(void *) * (size - 1)) : 0);
+    asdl_seq *seq = NULL;
+    size_t n = (size ? (sizeof(void *) * (size - 1)) : 0);
 
-	/* check size is sane */
-	if (size < 0 || size == INT_MIN || 
-		(size && ((size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
-		PyErr_NoMemory();
-		return NULL;
-	}
+    /* check size is sane */
+    if (size < 0 || size == INT_MIN ||
+        (size && ((size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
+        PyErr_NoMemory();
+        return NULL;
+    }
 
-	/* check if size can be added safely */
-	if (n > PY_SIZE_MAX - sizeof(asdl_seq)) {
-		PyErr_NoMemory();
-		return NULL;
-	}
+    /* check if size can be added safely */
+    if (n > PY_SIZE_MAX - sizeof(asdl_seq)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
 
-	n += sizeof(asdl_seq);
+    n += sizeof(asdl_seq);
 
-	seq = (asdl_seq *)PyArena_Malloc(arena, n);
-	if (!seq) {
-		PyErr_NoMemory();
-		return NULL;
-	}
-	memset(seq, 0, n);
-	seq->size = size;
-	return seq;
+    seq = (asdl_seq *)PyArena_Malloc(arena, n);
+    if (!seq) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    memset(seq, 0, n);
+    seq->size = size;
+    return seq;
 }
 
 asdl_int_seq *
 asdl_int_seq_new(int size, PyArena *arena)
 {
-	asdl_int_seq *seq = NULL;
-	size_t n = (size ? (sizeof(void *) * (size - 1)) : 0);
+    asdl_int_seq *seq = NULL;
+    size_t n = (size ? (sizeof(void *) * (size - 1)) : 0);
 
-	/* check size is sane */
-	if (size < 0 || size == INT_MIN || 
-		(size && ((size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
-			PyErr_NoMemory();
-			return NULL;
-	}
+    /* check size is sane */
+    if (size < 0 || size == INT_MIN ||
+        (size && ((size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
+            PyErr_NoMemory();
+            return NULL;
+    }
 
-	/* check if size can be added safely */
-	if (n > PY_SIZE_MAX - sizeof(asdl_seq)) {
-		PyErr_NoMemory();
-		return NULL;
-	}
+    /* check if size can be added safely */
+    if (n > PY_SIZE_MAX - sizeof(asdl_seq)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
 
-	n += sizeof(asdl_seq);
+    n += sizeof(asdl_seq);
 
-	seq = (asdl_int_seq *)PyArena_Malloc(arena, n);
-	if (!seq) {
-		PyErr_NoMemory();
-		return NULL;
-	}
-	memset(seq, 0, n);
-	seq->size = size;
-	return seq;
+    seq = (asdl_int_seq *)PyArena_Malloc(arena, n);
+    if (!seq) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    memset(seq, 0, n);
+    seq->size = size;
+    return seq;
 }
diff --git a/Python/atof.c b/Python/atof.c
index 8fbde38..562fcd6 100644
--- a/Python/atof.c
+++ b/Python/atof.c
@@ -10,41 +10,41 @@
 
 double atof(char *s)
 {
-	double a = 0.0;
-	int e = 0;
-	int c;
-	while ((c = *s++) != '\0' && isdigit(c)) {
-		a = a*10.0 + (c - '0');
-	}
-	if (c == '.') {
-		while ((c = *s++) != '\0' && isdigit(c)) {
-			a = a*10.0 + (c - '0');
-			e = e-1;
-		}
-	}
-	if (c == 'e' || c == 'E') {
-		int sign = 1;
-		int i = 0;
-		c = *s++;
-		if (c == '+')
-			c = *s++;
-		else if (c == '-') {
-			c = *s++;
-			sign = -1;
-		}
-		while (isdigit(c)) {
-			i = i*10 + (c - '0');
-			c = *s++;
-		}
-		e += i*sign;
-	}
-	while (e > 0) {
-		a *= 10.0;
-		e--;
-	}
-	while (e < 0) {
-		a *= 0.1;
-		e++;
-	}
-	return a;
+    double a = 0.0;
+    int e = 0;
+    int c;
+    while ((c = *s++) != '\0' && isdigit(c)) {
+        a = a*10.0 + (c - '0');
+    }
+    if (c == '.') {
+        while ((c = *s++) != '\0' && isdigit(c)) {
+            a = a*10.0 + (c - '0');
+            e = e-1;
+        }
+    }
+    if (c == 'e' || c == 'E') {
+        int sign = 1;
+        int i = 0;
+        c = *s++;
+        if (c == '+')
+            c = *s++;
+        else if (c == '-') {
+            c = *s++;
+            sign = -1;
+        }
+        while (isdigit(c)) {
+            i = i*10 + (c - '0');
+            c = *s++;
+        }
+        e += i*sign;
+    }
+    while (e > 0) {
+        a *= 10.0;
+        e--;
+    }
+    while (e < 0) {
+        a *= 0.1;
+        e++;
+    }
+    return a;
 }
diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c
index 40441d2..764ae87 100644
--- a/Python/bltinmodule.c
+++ b/Python/bltinmodule.c
@@ -35,19 +35,19 @@ static PyObject *filtertuple (PyObject *, PyObject *);
 static PyObject *
 builtin___import__(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	static char *kwlist[] = {"name", "globals", "locals", "fromlist",
-				 "level", 0};
-	char *name;
-	PyObject *globals = NULL;
-	PyObject *locals = NULL;
-	PyObject *fromlist = NULL;
-	int level = -1;
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|OOOi:__import__",
-			kwlist, &name, &globals, &locals, &fromlist, &level))
-		return NULL;
-	return PyImport_ImportModuleLevel(name, globals, locals,
-					  fromlist, level);
+    static char *kwlist[] = {"name", "globals", "locals", "fromlist",
+                             "level", 0};
+    char *name;
+    PyObject *globals = NULL;
+    PyObject *locals = NULL;
+    PyObject *fromlist = NULL;
+    int level = -1;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|OOOi:__import__",
+                    kwlist, &name, &globals, &locals, &fromlist, &level))
+        return NULL;
+    return PyImport_ImportModuleLevel(name, globals, locals,
+                                      fromlist, level);
 }
 
 PyDoc_STRVAR(import_doc,
@@ -68,7 +68,7 @@ is the number of parent directories to search relative to the current module.");
 static PyObject *
 builtin_abs(PyObject *self, PyObject *v)
 {
-	return PyNumber_Absolute(v);
+    return PyNumber_Absolute(v);
 }
 
 PyDoc_STRVAR(abs_doc,
@@ -79,38 +79,38 @@ Return the absolute value of the argument.");
 static PyObject *
 builtin_all(PyObject *self, PyObject *v)
 {
-	PyObject *it, *item;
-	PyObject *(*iternext)(PyObject *);
-	int cmp;
-
-	it = PyObject_GetIter(v);
-	if (it == NULL)
-		return NULL;
-	iternext = *Py_TYPE(it)->tp_iternext;
-
-	for (;;) {
-		item = iternext(it);
-		if (item == NULL)
-			break;
-		cmp = PyObject_IsTrue(item);
-		Py_DECREF(item);
-		if (cmp < 0) {
-			Py_DECREF(it);
-			return NULL;
-		}
-		if (cmp == 0) {
-			Py_DECREF(it);
-			Py_RETURN_FALSE;
-		}
-	}
-	Py_DECREF(it);
-	if (PyErr_Occurred()) {
-		if (PyErr_ExceptionMatches(PyExc_StopIteration))
-			PyErr_Clear();
-		else
-			return NULL;
-	}
-	Py_RETURN_TRUE;
+    PyObject *it, *item;
+    PyObject *(*iternext)(PyObject *);
+    int cmp;
+
+    it = PyObject_GetIter(v);
+    if (it == NULL)
+        return NULL;
+    iternext = *Py_TYPE(it)->tp_iternext;
+
+    for (;;) {
+        item = iternext(it);
+        if (item == NULL)
+            break;
+        cmp = PyObject_IsTrue(item);
+        Py_DECREF(item);
+        if (cmp < 0) {
+            Py_DECREF(it);
+            return NULL;
+        }
+        if (cmp == 0) {
+            Py_DECREF(it);
+            Py_RETURN_FALSE;
+        }
+    }
+    Py_DECREF(it);
+    if (PyErr_Occurred()) {
+        if (PyErr_ExceptionMatches(PyExc_StopIteration))
+            PyErr_Clear();
+        else
+            return NULL;
+    }
+    Py_RETURN_TRUE;
 }
 
 PyDoc_STRVAR(all_doc,
@@ -121,38 +121,38 @@ Return True if bool(x) is True for all values x in the iterable.");
 static PyObject *
 builtin_any(PyObject *self, PyObject *v)
 {
-	PyObject *it, *item;
-	PyObject *(*iternext)(PyObject *);
-	int cmp;
-
-	it = PyObject_GetIter(v);
-	if (it == NULL)
-		return NULL;
-	iternext = *Py_TYPE(it)->tp_iternext;
-
-	for (;;) {
-		item = iternext(it);
-		if (item == NULL)
-			break;
-		cmp = PyObject_IsTrue(item);
-		Py_DECREF(item);
-		if (cmp < 0) {
-			Py_DECREF(it);
-			return NULL;
-		}
-		if (cmp == 1) {
-			Py_DECREF(it);
-			Py_RETURN_TRUE;
-		}
-	}
-	Py_DECREF(it);
-	if (PyErr_Occurred()) {
-		if (PyErr_ExceptionMatches(PyExc_StopIteration))
-			PyErr_Clear();
-		else
-			return NULL;
-	}
-	Py_RETURN_FALSE;
+    PyObject *it, *item;
+    PyObject *(*iternext)(PyObject *);
+    int cmp;
+
+    it = PyObject_GetIter(v);
+    if (it == NULL)
+        return NULL;
+    iternext = *Py_TYPE(it)->tp_iternext;
+
+    for (;;) {
+        item = iternext(it);
+        if (item == NULL)
+            break;
+        cmp = PyObject_IsTrue(item);
+        Py_DECREF(item);
+        if (cmp < 0) {
+            Py_DECREF(it);
+            return NULL;
+        }
+        if (cmp == 1) {
+            Py_DECREF(it);
+            Py_RETURN_TRUE;
+        }
+    }
+    Py_DECREF(it);
+    if (PyErr_Occurred()) {
+        if (PyErr_ExceptionMatches(PyExc_StopIteration))
+            PyErr_Clear();
+        else
+            return NULL;
+    }
+    Py_RETURN_FALSE;
 }
 
 PyDoc_STRVAR(any_doc,
@@ -163,39 +163,39 @@ Return True if bool(x) is True for any x in the iterable.");
 static PyObject *
 builtin_apply(PyObject *self, PyObject *args)
 {
-	PyObject *func, *alist = NULL, *kwdict = NULL;
-	PyObject *t = NULL, *retval = NULL;
-
-	if (PyErr_WarnPy3k("apply() not supported in 3.x; "
-			   "use func(*args, **kwargs)", 1) < 0)
-		return NULL;
-
-	if (!PyArg_UnpackTuple(args, "apply", 1, 3, &func, &alist, &kwdict))
-		return NULL;
-	if (alist != NULL) {
-		if (!PyTuple_Check(alist)) {
-			if (!PySequence_Check(alist)) {
-				PyErr_Format(PyExc_TypeError,
-				     "apply() arg 2 expected sequence, found %s",
-					     alist->ob_type->tp_name);
-				return NULL;
-			}
-			t = PySequence_Tuple(alist);
-			if (t == NULL)
-				return NULL;
-			alist = t;
-		}
-	}
-	if (kwdict != NULL && !PyDict_Check(kwdict)) {
-		PyErr_Format(PyExc_TypeError,
-			     "apply() arg 3 expected dictionary, found %s",
-			     kwdict->ob_type->tp_name);
-		goto finally;
-	}
-	retval = PyEval_CallObjectWithKeywords(func, alist, kwdict);
+    PyObject *func, *alist = NULL, *kwdict = NULL;
+    PyObject *t = NULL, *retval = NULL;
+
+    if (PyErr_WarnPy3k("apply() not supported in 3.x; "
+                       "use func(*args, **kwargs)", 1) < 0)
+        return NULL;
+
+    if (!PyArg_UnpackTuple(args, "apply", 1, 3, &func, &alist, &kwdict))
+        return NULL;
+    if (alist != NULL) {
+        if (!PyTuple_Check(alist)) {
+            if (!PySequence_Check(alist)) {
+                PyErr_Format(PyExc_TypeError,
+                     "apply() arg 2 expected sequence, found %s",
+                         alist->ob_type->tp_name);
+                return NULL;
+            }
+            t = PySequence_Tuple(alist);
+            if (t == NULL)
+                return NULL;
+            alist = t;
+        }
+    }
+    if (kwdict != NULL && !PyDict_Check(kwdict)) {
+        PyErr_Format(PyExc_TypeError,
+                     "apply() arg 3 expected dictionary, found %s",
+                     kwdict->ob_type->tp_name);
+        goto finally;
+    }
+    retval = PyEval_CallObjectWithKeywords(func, alist, kwdict);
   finally:
-	Py_XDECREF(t);
-	return retval;
+    Py_XDECREF(t);
+    return retval;
 }
 
 PyDoc_STRVAR(apply_doc,
@@ -212,7 +212,7 @@ Deprecated since release 2.3. Instead, use the extended call syntax:\n\
 static PyObject *
 builtin_bin(PyObject *self, PyObject *v)
 {
-        return PyNumber_ToBase(v, 2);
+    return PyNumber_ToBase(v, 2);
 }
 
 PyDoc_STRVAR(bin_doc,
@@ -224,10 +224,10 @@ Return the binary representation of an integer or long integer.");
 static PyObject *
 builtin_callable(PyObject *self, PyObject *v)
 {
-	if (PyErr_WarnPy3k("callable() not supported in 3.x; "
-			   "use isinstance(x, collections.Callable)", 1) < 0)
-		return NULL;
-	return PyBool_FromLong((long)PyCallable_Check(v));
+    if (PyErr_WarnPy3k("callable() not supported in 3.x; "
+                       "use isinstance(x, collections.Callable)", 1) < 0)
+        return NULL;
+    return PyBool_FromLong((long)PyCallable_Check(v));
 }
 
 PyDoc_STRVAR(callable_doc,
@@ -240,109 +240,109 @@ Note that classes are callable, as are instances with a __call__() method.");
 static PyObject *
 builtin_filter(PyObject *self, PyObject *args)
 {
-	PyObject *func, *seq, *result, *it, *arg;
-	Py_ssize_t len;   /* guess for result list size */
-	register Py_ssize_t j;
+    PyObject *func, *seq, *result, *it, *arg;
+    Py_ssize_t len;   /* guess for result list size */
+    register Py_ssize_t j;
 
-	if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))
-		return NULL;
+    if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))
+        return NULL;
 
-	/* Strings and tuples return a result of the same type. */
-	if (PyString_Check(seq))
-		return filterstring(func, seq);
+    /* Strings and tuples return a result of the same type. */
+    if (PyString_Check(seq))
+        return filterstring(func, seq);
 #ifdef Py_USING_UNICODE
-	if (PyUnicode_Check(seq))
-		return filterunicode(func, seq);
+    if (PyUnicode_Check(seq))
+        return filterunicode(func, seq);
 #endif
-	if (PyTuple_Check(seq))
-		return filtertuple(func, seq);
-
-	/* Pre-allocate argument list tuple. */
-	arg = PyTuple_New(1);
-	if (arg == NULL)
-		return NULL;
-
-	/* Get iterator. */
-	it = PyObject_GetIter(seq);
-	if (it == NULL)
-		goto Fail_arg;
-
-	/* Guess a result list size. */
-	len = _PyObject_LengthHint(seq, 8);
-	if (len == -1)
-		goto Fail_it;
-
-	/* Get a result list. */
-	if (PyList_Check(seq) && seq->ob_refcnt == 1) {
-		/* Eww - can modify the list in-place. */
-		Py_INCREF(seq);
-		result = seq;
-	}
-	else {
-		result = PyList_New(len);
-		if (result == NULL)
-			goto Fail_it;
-	}
-
-	/* Build the result list. */
-	j = 0;
-	for (;;) {
-		PyObject *item;
-		int ok;
-
-		item = PyIter_Next(it);
-		if (item == NULL) {
-			if (PyErr_Occurred())
-				goto Fail_result_it;
-			break;
-		}
-
-		if (func == (PyObject *)&PyBool_Type || func == Py_None) {
-			ok = PyObject_IsTrue(item);
-		}
-		else {
-			PyObject *good;
-			PyTuple_SET_ITEM(arg, 0, item);
-			good = PyObject_Call(func, arg, NULL);
-			PyTuple_SET_ITEM(arg, 0, NULL);
-			if (good == NULL) {
-				Py_DECREF(item);
-				goto Fail_result_it;
-			}
-			ok = PyObject_IsTrue(good);
-			Py_DECREF(good);
-		}
-		if (ok) {
-			if (j < len)
-				PyList_SET_ITEM(result, j, item);
-			else {
-				int status = PyList_Append(result, item);
-				Py_DECREF(item);
-				if (status < 0)
-					goto Fail_result_it;
-			}
-			++j;
-		}
-		else
-			Py_DECREF(item);
-	}
-
-
-	/* Cut back result list if len is too big. */
-	if (j < len && PyList_SetSlice(result, j, len, NULL) < 0)
-		goto Fail_result_it;
-
-	Py_DECREF(it);
-	Py_DECREF(arg);
-	return result;
+    if (PyTuple_Check(seq))
+        return filtertuple(func, seq);
+
+    /* Pre-allocate argument list tuple. */
+    arg = PyTuple_New(1);
+    if (arg == NULL)
+        return NULL;
+
+    /* Get iterator. */
+    it = PyObject_GetIter(seq);
+    if (it == NULL)
+        goto Fail_arg;
+
+    /* Guess a result list size. */
+    len = _PyObject_LengthHint(seq, 8);
+    if (len == -1)
+        goto Fail_it;
+
+    /* Get a result list. */
+    if (PyList_Check(seq) && seq->ob_refcnt == 1) {
+        /* Eww - can modify the list in-place. */
+        Py_INCREF(seq);
+        result = seq;
+    }
+    else {
+        result = PyList_New(len);
+        if (result == NULL)
+            goto Fail_it;
+    }
+
+    /* Build the result list. */
+    j = 0;
+    for (;;) {
+        PyObject *item;
+        int ok;
+
+        item = PyIter_Next(it);
+        if (item == NULL) {
+            if (PyErr_Occurred())
+                goto Fail_result_it;
+            break;
+        }
+
+        if (func == (PyObject *)&PyBool_Type || func == Py_None) {
+            ok = PyObject_IsTrue(item);
+        }
+        else {
+            PyObject *good;
+            PyTuple_SET_ITEM(arg, 0, item);
+            good = PyObject_Call(func, arg, NULL);
+            PyTuple_SET_ITEM(arg, 0, NULL);
+            if (good == NULL) {
+                Py_DECREF(item);
+                goto Fail_result_it;
+            }
+            ok = PyObject_IsTrue(good);
+            Py_DECREF(good);
+        }
+        if (ok) {
+            if (j < len)
+                PyList_SET_ITEM(result, j, item);
+            else {
+                int status = PyList_Append(result, item);
+                Py_DECREF(item);
+                if (status < 0)
+                    goto Fail_result_it;
+            }
+            ++j;
+        }
+        else
+            Py_DECREF(item);
+    }
+
+
+    /* Cut back result list if len is too big. */
+    if (j < len && PyList_SetSlice(result, j, len, NULL) < 0)
+        goto Fail_result_it;
+
+    Py_DECREF(it);
+    Py_DECREF(arg);
+    return result;
 
 Fail_result_it:
-	Py_DECREF(result);
+    Py_DECREF(result);
 Fail_it:
-	Py_DECREF(it);
+    Py_DECREF(it);
 Fail_arg:
-	Py_DECREF(arg);
-	return NULL;
+    Py_DECREF(arg);
+    return NULL;
 }
 
 PyDoc_STRVAR(filter_doc,
@@ -355,13 +355,13 @@ PyDoc_STRVAR(filter_doc,
 static PyObject *
 builtin_format(PyObject *self, PyObject *args)
 {
-	PyObject *value;
-	PyObject *format_spec = NULL;
+    PyObject *value;
+    PyObject *format_spec = NULL;
 
-	if (!PyArg_ParseTuple(args, "O|O:format", &value, &format_spec))
-		return NULL;
+    if (!PyArg_ParseTuple(args, "O|O:format", &value, &format_spec))
+        return NULL;
 
-	return PyObject_Format(value, format_spec);
+    return PyObject_Format(value, format_spec);
 }
 
 PyDoc_STRVAR(format_doc,
@@ -373,18 +373,18 @@ format_spec defaults to \"\"");
 static PyObject *
 builtin_chr(PyObject *self, PyObject *args)
 {
-	long x;
-	char s[1];
-
-	if (!PyArg_ParseTuple(args, "l:chr", &x))
-		return NULL;
-	if (x < 0 || x >= 256) {
-		PyErr_SetString(PyExc_ValueError,
-				"chr() arg not in range(256)");
-		return NULL;
-	}
-	s[0] = (char)x;
-	return PyString_FromStringAndSize(s, 1);
+    long x;
+    char s[1];
+
+    if (!PyArg_ParseTuple(args, "l:chr", &x))
+        return NULL;
+    if (x < 0 || x >= 256) {
+        PyErr_SetString(PyExc_ValueError,
+                        "chr() arg not in range(256)");
+        return NULL;
+    }
+    s[0] = (char)x;
+    return PyString_FromStringAndSize(s, 1);
 }
 
 PyDoc_STRVAR(chr_doc,
@@ -397,12 +397,12 @@ Return a string of one character with ordinal i; 0 <= i < 256.");
 static PyObject *
 builtin_unichr(PyObject *self, PyObject *args)
 {
-	int x;
+    int x;
 
-	if (!PyArg_ParseTuple(args, "i:unichr", &x))
-		return NULL;
+    if (!PyArg_ParseTuple(args, "i:unichr", &x))
+        return NULL;
 
-	return PyUnicode_FromOrdinal(x);
+    return PyUnicode_FromOrdinal(x);
 }
 
 PyDoc_STRVAR(unichr_doc,
@@ -415,14 +415,14 @@ Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.");
 static PyObject *
 builtin_cmp(PyObject *self, PyObject *args)
 {
-	PyObject *a, *b;
-	int c;
-
-	if (!PyArg_UnpackTuple(args, "cmp", 2, 2, &a, &b))
-		return NULL;
-	if (PyObject_Cmp(a, b, &c) < 0)
-		return NULL;
-	return PyInt_FromLong((long)c);
+    PyObject *a, *b;
+    int c;
+
+    if (!PyArg_UnpackTuple(args, "cmp", 2, 2, &a, &b))
+        return NULL;
+    if (PyObject_Cmp(a, b, &c) < 0)
+        return NULL;
+    return PyInt_FromLong((long)c);
 }
 
 PyDoc_STRVAR(cmp_doc,
@@ -434,20 +434,20 @@ Return negative if x<y, zero if x==y, positive if x>y.");
 static PyObject *
 builtin_coerce(PyObject *self, PyObject *args)
 {
-	PyObject *v, *w;
-	PyObject *res;
-
-	if (PyErr_WarnPy3k("coerce() not supported in 3.x", 1) < 0)
-		return NULL;
-
-	if (!PyArg_UnpackTuple(args, "coerce", 2, 2, &v, &w))
-		return NULL;
-	if (PyNumber_Coerce(&v, &w) < 0)
-		return NULL;
-	res = PyTuple_Pack(2, v, w);
-	Py_DECREF(v);
-	Py_DECREF(w);
-	return res;
+    PyObject *v, *w;
+    PyObject *res;
+
+    if (PyErr_WarnPy3k("coerce() not supported in 3.x", 1) < 0)
+        return NULL;
+
+    if (!PyArg_UnpackTuple(args, "coerce", 2, 2, &v, &w))
+        return NULL;
+    if (PyNumber_Coerce(&v, &w) < 0)
+        return NULL;
+    res = PyTuple_Pack(2, v, w);
+    Py_DECREF(v);
+    Py_DECREF(w);
+    return res;
 }
 
 PyDoc_STRVAR(coerce_doc,
@@ -460,98 +460,98 @@ If coercion is not possible, raise TypeError.");
 static PyObject *
 builtin_compile(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	char *str;
-	char *filename;
-	char *startstr;
-	int mode = -1;
-	int dont_inherit = 0;
-	int supplied_flags = 0;
-	int is_ast;
-	PyCompilerFlags cf;
-	PyObject *result = NULL, *cmd, *tmp = NULL;
-	Py_ssize_t length;
-	static char *kwlist[] = {"source", "filename", "mode", "flags",
-				 "dont_inherit", NULL};
-	int start[] = {Py_file_input, Py_eval_input, Py_single_input};
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oss|ii:compile",
-					 kwlist, &cmd, &filename, &startstr,
-					 &supplied_flags, &dont_inherit))
-		return NULL;
-
-	cf.cf_flags = supplied_flags;
-
-	if (supplied_flags &
-	    ~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT | PyCF_ONLY_AST))
-	{
-		PyErr_SetString(PyExc_ValueError,
-				"compile(): unrecognised flags");
-		return NULL;
-	}
-	/* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */
-
-	if (!dont_inherit) {
-		PyEval_MergeCompilerFlags(&cf);
-	}
-
-	if (strcmp(startstr, "exec") == 0)
-		mode = 0;
-	else if (strcmp(startstr, "eval") == 0)
-		mode = 1;
-	else if (strcmp(startstr, "single") == 0)
-		mode = 2;
-	else {
-		PyErr_SetString(PyExc_ValueError,
-				"compile() arg 3 must be 'exec', 'eval' or 'single'");
-		return NULL;
-	}
-
-	is_ast = PyAST_Check(cmd);
-	if (is_ast == -1)
-		return NULL;
-	if (is_ast) {
-		if (supplied_flags & PyCF_ONLY_AST) {
-			Py_INCREF(cmd);
-			result = cmd;
-		}
-		else {
-			PyArena *arena;
-			mod_ty mod;
-
-			arena = PyArena_New();
-			mod = PyAST_obj2mod(cmd, arena, mode);
-			if (mod == NULL) {
-				PyArena_Free(arena);
-				return NULL;
-			}
-			result = (PyObject*)PyAST_Compile(mod, filename,
-							  &cf, arena);
-			PyArena_Free(arena);
-		}
-		return result;
-	}
+    char *str;
+    char *filename;
+    char *startstr;
+    int mode = -1;
+    int dont_inherit = 0;
+    int supplied_flags = 0;
+    int is_ast;
+    PyCompilerFlags cf;
+    PyObject *result = NULL, *cmd, *tmp = NULL;
+    Py_ssize_t length;
+    static char *kwlist[] = {"source", "filename", "mode", "flags",
+                             "dont_inherit", NULL};
+    int start[] = {Py_file_input, Py_eval_input, Py_single_input};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oss|ii:compile",
+                                     kwlist, &cmd, &filename, &startstr,
+                                     &supplied_flags, &dont_inherit))
+        return NULL;
+
+    cf.cf_flags = supplied_flags;
+
+    if (supplied_flags &
+        ~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT | PyCF_ONLY_AST))
+    {
+        PyErr_SetString(PyExc_ValueError,
+                        "compile(): unrecognised flags");
+        return NULL;
+    }
+    /* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */
+
+    if (!dont_inherit) {
+        PyEval_MergeCompilerFlags(&cf);
+    }
+
+    if (strcmp(startstr, "exec") == 0)
+        mode = 0;
+    else if (strcmp(startstr, "eval") == 0)
+        mode = 1;
+    else if (strcmp(startstr, "single") == 0)
+        mode = 2;
+    else {
+        PyErr_SetString(PyExc_ValueError,
+                        "compile() arg 3 must be 'exec', 'eval' or 'single'");
+        return NULL;
+    }
+
+    is_ast = PyAST_Check(cmd);
+    if (is_ast == -1)
+        return NULL;
+    if (is_ast) {
+        if (supplied_flags & PyCF_ONLY_AST) {
+            Py_INCREF(cmd);
+            result = cmd;
+        }
+        else {
+            PyArena *arena;
+            mod_ty mod;
+
+            arena = PyArena_New();
+            mod = PyAST_obj2mod(cmd, arena, mode);
+            if (mod == NULL) {
+                PyArena_Free(arena);
+                return NULL;
+            }
+            result = (PyObject*)PyAST_Compile(mod, filename,
+                                              &cf, arena);
+            PyArena_Free(arena);
+        }
+        return result;
+    }
 
 #ifdef Py_USING_UNICODE
-	if (PyUnicode_Check(cmd)) {
-		tmp = PyUnicode_AsUTF8String(cmd);
-		if (tmp == NULL)
-			return NULL;
-		cmd = tmp;
-		cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
-	}
+    if (PyUnicode_Check(cmd)) {
+        tmp = PyUnicode_AsUTF8String(cmd);
+        if (tmp == NULL)
+            return NULL;
+        cmd = tmp;
+        cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
+    }
 #endif
 
-	if (PyObject_AsReadBuffer(cmd, (const void **)&str, &length))
-		goto cleanup;
-	if ((size_t)length != strlen(str)) {
-		PyErr_SetString(PyExc_TypeError,
-				"compile() expected string without null bytes");
-		goto cleanup;
-	}
-	result = Py_CompileStringFlags(str, filename, start[mode], &cf);
+    if (PyObject_AsReadBuffer(cmd, (const void **)&str, &length))
+        goto cleanup;
+    if ((size_t)length != strlen(str)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "compile() expected string without null bytes");
+        goto cleanup;
+    }
+    result = Py_CompileStringFlags(str, filename, start[mode], &cf);
 cleanup:
-	Py_XDECREF(tmp);
-	return result;
+    Py_XDECREF(tmp);
+    return result;
 }
 
 PyDoc_STRVAR(compile_doc,
@@ -572,11 +572,11 @@ in addition to any features explicitly specified.");
 static PyObject *
 builtin_dir(PyObject *self, PyObject *args)
 {
-	PyObject *arg = NULL;
+    PyObject *arg = NULL;
 
-	if (!PyArg_UnpackTuple(args, "dir", 0, 1, &arg))
-		return NULL;
-	return PyObject_Dir(arg);
+    if (!PyArg_UnpackTuple(args, "dir", 0, 1, &arg))
+        return NULL;
+    return PyObject_Dir(arg);
 }
 
 PyDoc_STRVAR(dir_doc,
@@ -596,11 +596,11 @@ PyDoc_STRVAR(dir_doc,
 static PyObject *
 builtin_divmod(PyObject *self, PyObject *args)
 {
-	PyObject *v, *w;
+    PyObject *v, *w;
 
-	if (!PyArg_UnpackTuple(args, "divmod", 2, 2, &v, &w))
-		return NULL;
-	return PyNumber_Divmod(v, w);
+    if (!PyArg_UnpackTuple(args, "divmod", 2, 2, &v, &w))
+        return NULL;
+    return PyNumber_Divmod(v, w);
 }
 
 PyDoc_STRVAR(divmod_doc,
@@ -612,81 +612,81 @@ Return the tuple ((x-x%y)/y, x%y).  Invariant: div*y + mod == x.");
 static PyObject *
 builtin_eval(PyObject *self, PyObject *args)
 {
-	PyObject *cmd, *result, *tmp = NULL;
-	PyObject *globals = Py_None, *locals = Py_None;
-	char *str;
-	PyCompilerFlags cf;
-
-	if (!PyArg_UnpackTuple(args, "eval", 1, 3, &cmd, &globals, &locals))
-		return NULL;
-	if (locals != Py_None && !PyMapping_Check(locals)) {
-		PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
-		return NULL;
-	}
-	if (globals != Py_None && !PyDict_Check(globals)) {
-		PyErr_SetString(PyExc_TypeError, PyMapping_Check(globals) ?
-			"globals must be a real dict; try eval(expr, {}, mapping)"
-			: "globals must be a dict");
-		return NULL;
-	}
-	if (globals == Py_None) {
-		globals = PyEval_GetGlobals();
-		if (locals == Py_None)
-			locals = PyEval_GetLocals();
-	}
-	else if (locals == Py_None)
-		locals = globals;
-
-	if (globals == NULL || locals == NULL) {
-		PyErr_SetString(PyExc_TypeError, 
-			"eval must be given globals and locals "
-			"when called without a frame");
-		return NULL;
-	}
-
-	if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
-		if (PyDict_SetItemString(globals, "__builtins__",
-					 PyEval_GetBuiltins()) != 0)
-			return NULL;
-	}
-
-	if (PyCode_Check(cmd)) {
-		if (PyCode_GetNumFree((PyCodeObject *)cmd) > 0) {
-			PyErr_SetString(PyExc_TypeError,
-		"code object passed to eval() may not contain free variables");
-			return NULL;
-		}
-		return PyEval_EvalCode((PyCodeObject *) cmd, globals, locals);
-	}
-
-	if (!PyString_Check(cmd) &&
-	    !PyUnicode_Check(cmd)) {
-		PyErr_SetString(PyExc_TypeError,
-			   "eval() arg 1 must be a string or code object");
-		return NULL;
-	}
-	cf.cf_flags = 0;
+    PyObject *cmd, *result, *tmp = NULL;
+    PyObject *globals = Py_None, *locals = Py_None;
+    char *str;
+    PyCompilerFlags cf;
+
+    if (!PyArg_UnpackTuple(args, "eval", 1, 3, &cmd, &globals, &locals))
+        return NULL;
+    if (locals != Py_None && !PyMapping_Check(locals)) {
+        PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
+        return NULL;
+    }
+    if (globals != Py_None && !PyDict_Check(globals)) {
+        PyErr_SetString(PyExc_TypeError, PyMapping_Check(globals) ?
+            "globals must be a real dict; try eval(expr, {}, mapping)"
+            : "globals must be a dict");
+        return NULL;
+    }
+    if (globals == Py_None) {
+        globals = PyEval_GetGlobals();
+        if (locals == Py_None)
+            locals = PyEval_GetLocals();
+    }
+    else if (locals == Py_None)
+        locals = globals;
+
+    if (globals == NULL || locals == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+            "eval must be given globals and locals "
+            "when called without a frame");
+        return NULL;
+    }
+
+    if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
+        if (PyDict_SetItemString(globals, "__builtins__",
+                                 PyEval_GetBuiltins()) != 0)
+            return NULL;
+    }
+
+    if (PyCode_Check(cmd)) {
+        if (PyCode_GetNumFree((PyCodeObject *)cmd) > 0) {
+            PyErr_SetString(PyExc_TypeError,
+        "code object passed to eval() may not contain free variables");
+            return NULL;
+        }
+        return PyEval_EvalCode((PyCodeObject *) cmd, globals, locals);
+    }
+
+    if (!PyString_Check(cmd) &&
+        !PyUnicode_Check(cmd)) {
+        PyErr_SetString(PyExc_TypeError,
+                   "eval() arg 1 must be a string or code object");
+        return NULL;
+    }
+    cf.cf_flags = 0;
 
 #ifdef Py_USING_UNICODE
-	if (PyUnicode_Check(cmd)) {
-		tmp = PyUnicode_AsUTF8String(cmd);
-		if (tmp == NULL)
-			return NULL;
-		cmd = tmp;
-		cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
-	}
+    if (PyUnicode_Check(cmd)) {
+        tmp = PyUnicode_AsUTF8String(cmd);
+        if (tmp == NULL)
+            return NULL;
+        cmd = tmp;
+        cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
+    }
 #endif
-	if (PyString_AsStringAndSize(cmd, &str, NULL)) {
-		Py_XDECREF(tmp);
-		return NULL;
-	}
-	while (*str == ' ' || *str == '\t')
-		str++;
-
-	(void)PyEval_MergeCompilerFlags(&cf);
-	result = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
-	Py_XDECREF(tmp);
-	return result;
+    if (PyString_AsStringAndSize(cmd, &str, NULL)) {
+        Py_XDECREF(tmp);
+        return NULL;
+    }
+    while (*str == ' ' || *str == '\t')
+        str++;
+
+    (void)PyEval_MergeCompilerFlags(&cf);
+    result = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
+    Py_XDECREF(tmp);
+    return result;
 }
 
 PyDoc_STRVAR(eval_doc,
@@ -703,98 +703,98 @@ If only globals is given, locals defaults to it.\n");
 static PyObject *
 builtin_execfile(PyObject *self, PyObject *args)
 {
-	char *filename;
-	PyObject *globals = Py_None, *locals = Py_None;
-	PyObject *res;
-	FILE* fp = NULL;
-	PyCompilerFlags cf;
-	int exists;
-
-	if (PyErr_WarnPy3k("execfile() not supported in 3.x; use exec()",
-			   1) < 0)
-		return NULL;
-
-	if (!PyArg_ParseTuple(args, "s|O!O:execfile",
-			&filename,
-			&PyDict_Type, &globals,
-			&locals))
-		return NULL;
-	if (locals != Py_None && !PyMapping_Check(locals)) {
-		PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
-		return NULL;
-	}
-	if (globals == Py_None) {
-		globals = PyEval_GetGlobals();
-		if (locals == Py_None)
-			locals = PyEval_GetLocals();
-	}
-	else if (locals == Py_None)
-		locals = globals;
-	if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
-		if (PyDict_SetItemString(globals, "__builtins__",
-					 PyEval_GetBuiltins()) != 0)
-			return NULL;
-	}
-
-	exists = 0;
-	/* Test for existence or directory. */
+    char *filename;
+    PyObject *globals = Py_None, *locals = Py_None;
+    PyObject *res;
+    FILE* fp = NULL;
+    PyCompilerFlags cf;
+    int exists;
+
+    if (PyErr_WarnPy3k("execfile() not supported in 3.x; use exec()",
+                       1) < 0)
+        return NULL;
+
+    if (!PyArg_ParseTuple(args, "s|O!O:execfile",
+                    &filename,
+                    &PyDict_Type, &globals,
+                    &locals))
+        return NULL;
+    if (locals != Py_None && !PyMapping_Check(locals)) {
+        PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
+        return NULL;
+    }
+    if (globals == Py_None) {
+        globals = PyEval_GetGlobals();
+        if (locals == Py_None)
+            locals = PyEval_GetLocals();
+    }
+    else if (locals == Py_None)
+        locals = globals;
+    if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
+        if (PyDict_SetItemString(globals, "__builtins__",
+                                 PyEval_GetBuiltins()) != 0)
+            return NULL;
+    }
+
+    exists = 0;
+    /* Test for existence or directory. */
 #if defined(PLAN9)
-	{
-		Dir *d;
-
-		if ((d = dirstat(filename))!=nil) {
-			if(d->mode & DMDIR)
-				werrstr("is a directory");
-			else
-				exists = 1;
-			free(d);
-		}
-	}
+    {
+        Dir *d;
+
+        if ((d = dirstat(filename))!=nil) {
+            if(d->mode & DMDIR)
+                werrstr("is a directory");
+            else
+                exists = 1;
+            free(d);
+        }
+    }
 #elif defined(RISCOS)
-	if (object_exists(filename)) {
-		if (isdir(filename))
-			errno = EISDIR;
-		else
-			exists = 1;
-	}
-#else	/* standard Posix */
-	{
-		struct stat s;
-		if (stat(filename, &s) == 0) {
-			if (S_ISDIR(s.st_mode))
-#				if defined(PYOS_OS2) && defined(PYCC_VACPP)
-					errno = EOS2ERR;
-#				else
-					errno = EISDIR;
-#				endif
-			else
-				exists = 1;
-		}
-	}
+    if (object_exists(filename)) {
+        if (isdir(filename))
+            errno = EISDIR;
+        else
+            exists = 1;
+    }
+#else   /* standard Posix */
+    {
+        struct stat s;
+        if (stat(filename, &s) == 0) {
+            if (S_ISDIR(s.st_mode))
+#                               if defined(PYOS_OS2) && defined(PYCC_VACPP)
+                            errno = EOS2ERR;
+#                               else
+                            errno = EISDIR;
+#                               endif
+            else
+                exists = 1;
+        }
+    }
 #endif
 
-        if (exists) {
-		Py_BEGIN_ALLOW_THREADS
-		fp = fopen(filename, "r" PY_STDIOTEXTMODE);
-		Py_END_ALLOW_THREADS
-
-		if (fp == NULL) {
-			exists = 0;
-		}
-        }
-
-	if (!exists) {
-		PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
-		return NULL;
-	}
-	cf.cf_flags = 0;
-	if (PyEval_MergeCompilerFlags(&cf))
-		res = PyRun_FileExFlags(fp, filename, Py_file_input, globals,
-				   locals, 1, &cf);
-	else
-		res = PyRun_FileEx(fp, filename, Py_file_input, globals,
-				   locals, 1);
-	return res;
+    if (exists) {
+        Py_BEGIN_ALLOW_THREADS
+        fp = fopen(filename, "r" PY_STDIOTEXTMODE);
+        Py_END_ALLOW_THREADS
+
+        if (fp == NULL) {
+            exists = 0;
+        }
+    }
+
+    if (!exists) {
+        PyErr_SetFromErrnoWithFilename(PyExc_IOError, filename);
+        return NULL;
+    }
+    cf.cf_flags = 0;
+    if (PyEval_MergeCompilerFlags(&cf))
+        res = PyRun_FileExFlags(fp, filename, Py_file_input, globals,
+                           locals, 1, &cf);
+    else
+        res = PyRun_FileEx(fp, filename, Py_file_input, globals,
+                           locals, 1);
+    return res;
 }
 
 PyDoc_STRVAR(execfile_doc,
@@ -808,33 +808,33 @@ globals and locals.  If only globals is given, locals defaults to it.");
 static PyObject *
 builtin_getattr(PyObject *self, PyObject *args)
 {
-	PyObject *v, *result, *dflt = NULL;
-	PyObject *name;
+    PyObject *v, *result, *dflt = NULL;
+    PyObject *name;
 
-	if (!PyArg_UnpackTuple(args, "getattr", 2, 3, &v, &name, &dflt))
-		return NULL;
+    if (!PyArg_UnpackTuple(args, "getattr", 2, 3, &v, &name, &dflt))
+        return NULL;
 #ifdef Py_USING_UNICODE
-	if (PyUnicode_Check(name)) {
-		name = _PyUnicode_AsDefaultEncodedString(name, NULL);
-		if (name == NULL)
-			return NULL;
-	}
+    if (PyUnicode_Check(name)) {
+        name = _PyUnicode_AsDefaultEncodedString(name, NULL);
+        if (name == NULL)
+            return NULL;
+    }
 #endif
 
-	if (!PyString_Check(name)) {
-		PyErr_SetString(PyExc_TypeError,
-				"getattr(): attribute name must be string");
-		return NULL;
-	}
-	result = PyObject_GetAttr(v, name);
-	if (result == NULL && dflt != NULL &&
-	    PyErr_ExceptionMatches(PyExc_AttributeError))
-	{
-		PyErr_Clear();
-		Py_INCREF(dflt);
-		result = dflt;
-	}
-	return result;
+    if (!PyString_Check(name)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "getattr(): attribute name must be string");
+        return NULL;
+    }
+    result = PyObject_GetAttr(v, name);
+    if (result == NULL && dflt != NULL &&
+        PyErr_ExceptionMatches(PyExc_AttributeError))
+    {
+        PyErr_Clear();
+        Py_INCREF(dflt);
+        result = dflt;
+    }
+    return result;
 }
 
 PyDoc_STRVAR(getattr_doc,
@@ -848,11 +848,11 @@ exist; without it, an exception is raised in that case.");
 static PyObject *
 builtin_globals(PyObject *self)
 {
-	PyObject *d;
+    PyObject *d;
 
-	d = PyEval_GetGlobals();
-	Py_XINCREF(d);
-	return d;
+    d = PyEval_GetGlobals();
+    Py_XINCREF(d);
+    return d;
 }
 
 PyDoc_STRVAR(globals_doc,
@@ -864,37 +864,37 @@ Return the dictionary containing the current scope's global variables.");
 static PyObject *
 builtin_hasattr(PyObject *self, PyObject *args)
 {
-	PyObject *v;
-	PyObject *name;
+    PyObject *v;
+    PyObject *name;
 
-	if (!PyArg_UnpackTuple(args, "hasattr", 2, 2, &v, &name))
-		return NULL;
+    if (!PyArg_UnpackTuple(args, "hasattr", 2, 2, &v, &name))
+        return NULL;
 #ifdef Py_USING_UNICODE
-	if (PyUnicode_Check(name)) {
-		name = _PyUnicode_AsDefaultEncodedString(name, NULL);
-		if (name == NULL)
-			return NULL;
-	}
+    if (PyUnicode_Check(name)) {
+        name = _PyUnicode_AsDefaultEncodedString(name, NULL);
+        if (name == NULL)
+            return NULL;
+    }
 #endif
 
-	if (!PyString_Check(name)) {
-		PyErr_SetString(PyExc_TypeError,
-				"hasattr(): attribute name must be string");
-		return NULL;
-	}
-	v = PyObject_GetAttr(v, name);
-	if (v == NULL) {
-		if (!PyErr_ExceptionMatches(PyExc_Exception))
-			return NULL;
-		else {
-			PyErr_Clear();
-			Py_INCREF(Py_False);
-			return Py_False;
-		}
-	}
-	Py_DECREF(v);
-	Py_INCREF(Py_True);
-	return Py_True;
+    if (!PyString_Check(name)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "hasattr(): attribute name must be string");
+        return NULL;
+    }
+    v = PyObject_GetAttr(v, name);
+    if (v == NULL) {
+        if (!PyErr_ExceptionMatches(PyExc_Exception))
+            return NULL;
+        else {
+            PyErr_Clear();
+            Py_INCREF(Py_False);
+            return Py_False;
+        }
+    }
+    Py_DECREF(v);
+    Py_INCREF(Py_True);
+    return Py_True;
 }
 
 PyDoc_STRVAR(hasattr_doc,
@@ -907,7 +907,7 @@ Return whether the object has an attribute with the given name.\n\
 static PyObject *
 builtin_id(PyObject *self, PyObject *v)
 {
-	return PyLong_FromVoidPtr(v);
+    return PyLong_FromVoidPtr(v);
 }
 
 PyDoc_STRVAR(id_doc,
@@ -920,154 +920,154 @@ simultaneously existing objects.  (Hint: it's the object's memory address.)");
 static PyObject *
 builtin_map(PyObject *self, PyObject *args)
 {
-	typedef struct {
-		PyObject *it;	/* the iterator object */
-		int saw_StopIteration;  /* bool:  did the iterator end? */
-	} sequence;
-
-	PyObject *func, *result;
-	sequence *seqs = NULL, *sqp;
-	Py_ssize_t n, len;
-	register int i, j;
-
-	n = PyTuple_Size(args);
-	if (n < 2) {
-		PyErr_SetString(PyExc_TypeError,
-				"map() requires at least two args");
-		return NULL;
-	}
-
-	func = PyTuple_GetItem(args, 0);
-	n--;
-
-	if (func == Py_None) {
-		if (PyErr_WarnPy3k("map(None, ...) not supported in 3.x; "
-				   "use list(...)", 1) < 0)
-			return NULL;
-		if (n == 1) {
-			/* map(None, S) is the same as list(S). */
-			return PySequence_List(PyTuple_GetItem(args, 1));
-		}
-	}
-
-	/* Get space for sequence descriptors.  Must NULL out the iterator
-	 * pointers so that jumping to Fail_2 later doesn't see trash.
-	 */
-	if ((seqs = PyMem_NEW(sequence, n)) == NULL) {
-		PyErr_NoMemory();
-		return NULL;
-	}
-	for (i = 0; i < n; ++i) {
-		seqs[i].it = (PyObject*)NULL;
-		seqs[i].saw_StopIteration = 0;
-	}
-
-	/* Do a first pass to obtain iterators for the arguments, and set len
-	 * to the largest of their lengths.
-	 */
-	len = 0;
-	for (i = 0, sqp = seqs; i < n; ++i, ++sqp) {
-		PyObject *curseq;
-		Py_ssize_t curlen;
-
-		/* Get iterator. */
-		curseq = PyTuple_GetItem(args, i+1);
-		sqp->it = PyObject_GetIter(curseq);
-		if (sqp->it == NULL) {
-			static char errmsg[] =
-			    "argument %d to map() must support iteration";
-			char errbuf[sizeof(errmsg) + 25];
-			PyOS_snprintf(errbuf, sizeof(errbuf), errmsg, i+2);
-			PyErr_SetString(PyExc_TypeError, errbuf);
-			goto Fail_2;
-		}
-
-		/* Update len. */
-		curlen = _PyObject_LengthHint(curseq, 8);
-		if (curlen > len)
-			len = curlen;
-	}
-
-	/* Get space for the result list. */
-	if ((result = (PyObject *) PyList_New(len)) == NULL)
-		goto Fail_2;
-
-	/* Iterate over the sequences until all have stopped. */
-	for (i = 0; ; ++i) {
-		PyObject *alist, *item=NULL, *value;
-		int numactive = 0;
-
-		if (func == Py_None && n == 1)
-			alist = NULL;
-		else if ((alist = PyTuple_New(n)) == NULL)
-			goto Fail_1;
-
-		for (j = 0, sqp = seqs; j < n; ++j, ++sqp) {
-			if (sqp->saw_StopIteration) {
-				Py_INCREF(Py_None);
-				item = Py_None;
-			}
-			else {
-				item = PyIter_Next(sqp->it);
-				if (item)
-					++numactive;
-				else {
-					if (PyErr_Occurred()) {
-						Py_XDECREF(alist);
-						goto Fail_1;
-					}
-					Py_INCREF(Py_None);
-					item = Py_None;
-					sqp->saw_StopIteration = 1;
-				}
-			}
-			if (alist)
-				PyTuple_SET_ITEM(alist, j, item);
-			else
-				break;
-		}
-
-		if (!alist)
-			alist = item;
-
-		if (numactive == 0) {
-			Py_DECREF(alist);
-			break;
-		}
-
-		if (func == Py_None)
-			value = alist;
-		else {
-			value = PyEval_CallObject(func, alist);
-			Py_DECREF(alist);
-			if (value == NULL)
-				goto Fail_1;
-		}
-		if (i >= len) {
-			int status = PyList_Append(result, value);
-			Py_DECREF(value);
-			if (status < 0)
-				goto Fail_1;
-		}
-		else if (PyList_SetItem(result, i, value) < 0)
-		 	goto Fail_1;
-	}
-
-	if (i < len && PyList_SetSlice(result, i, len, NULL) < 0)
-		goto Fail_1;
-
-	goto Succeed;
+    typedef struct {
+        PyObject *it;           /* the iterator object */
+        int saw_StopIteration;  /* bool:  did the iterator end? */
+    } sequence;
+
+    PyObject *func, *result;
+    sequence *seqs = NULL, *sqp;
+    Py_ssize_t n, len;
+    register int i, j;
+
+    n = PyTuple_Size(args);
+    if (n < 2) {
+        PyErr_SetString(PyExc_TypeError,
+                        "map() requires at least two args");
+        return NULL;
+    }
+
+    func = PyTuple_GetItem(args, 0);
+    n--;
+
+    if (func == Py_None) {
+        if (PyErr_WarnPy3k("map(None, ...) not supported in 3.x; "
+                           "use list(...)", 1) < 0)
+            return NULL;
+        if (n == 1) {
+            /* map(None, S) is the same as list(S). */
+            return PySequence_List(PyTuple_GetItem(args, 1));
+        }
+    }
+
+    /* Get space for sequence descriptors.  Must NULL out the iterator
+     * pointers so that jumping to Fail_2 later doesn't see trash.
+     */
+    if ((seqs = PyMem_NEW(sequence, n)) == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (i = 0; i < n; ++i) {
+        seqs[i].it = (PyObject*)NULL;
+        seqs[i].saw_StopIteration = 0;
+    }
+
+    /* Do a first pass to obtain iterators for the arguments, and set len
+     * to the largest of their lengths.
+     */
+    len = 0;
+    for (i = 0, sqp = seqs; i < n; ++i, ++sqp) {
+        PyObject *curseq;
+        Py_ssize_t curlen;
+
+        /* Get iterator. */
+        curseq = PyTuple_GetItem(args, i+1);
+        sqp->it = PyObject_GetIter(curseq);
+        if (sqp->it == NULL) {
+            static char errmsg[] =
+                "argument %d to map() must support iteration";
+            char errbuf[sizeof(errmsg) + 25];
+            PyOS_snprintf(errbuf, sizeof(errbuf), errmsg, i+2);
+            PyErr_SetString(PyExc_TypeError, errbuf);
+            goto Fail_2;
+        }
+
+        /* Update len. */
+        curlen = _PyObject_LengthHint(curseq, 8);
+        if (curlen > len)
+            len = curlen;
+    }
+
+    /* Get space for the result list. */
+    if ((result = (PyObject *) PyList_New(len)) == NULL)
+        goto Fail_2;
+
+    /* Iterate over the sequences until all have stopped. */
+    for (i = 0; ; ++i) {
+        PyObject *alist, *item=NULL, *value;
+        int numactive = 0;
+
+        if (func == Py_None && n == 1)
+            alist = NULL;
+        else if ((alist = PyTuple_New(n)) == NULL)
+            goto Fail_1;
+
+        for (j = 0, sqp = seqs; j < n; ++j, ++sqp) {
+            if (sqp->saw_StopIteration) {
+                Py_INCREF(Py_None);
+                item = Py_None;
+            }
+            else {
+                item = PyIter_Next(sqp->it);
+                if (item)
+                    ++numactive;
+                else {
+                    if (PyErr_Occurred()) {
+                        Py_XDECREF(alist);
+                        goto Fail_1;
+                    }
+                    Py_INCREF(Py_None);
+                    item = Py_None;
+                    sqp->saw_StopIteration = 1;
+                }
+            }
+            if (alist)
+                PyTuple_SET_ITEM(alist, j, item);
+            else
+                break;
+        }
+
+        if (!alist)
+            alist = item;
+
+        if (numactive == 0) {
+            Py_DECREF(alist);
+            break;
+        }
+
+        if (func == Py_None)
+            value = alist;
+        else {
+            value = PyEval_CallObject(func, alist);
+            Py_DECREF(alist);
+            if (value == NULL)
+                goto Fail_1;
+        }
+        if (i >= len) {
+            int status = PyList_Append(result, value);
+            Py_DECREF(value);
+            if (status < 0)
+                goto Fail_1;
+        }
+        else if (PyList_SetItem(result, i, value) < 0)
+            goto Fail_1;
+    }
+
+    if (i < len && PyList_SetSlice(result, i, len, NULL) < 0)
+        goto Fail_1;
+
+    goto Succeed;
 
 Fail_1:
-	Py_DECREF(result);
+    Py_DECREF(result);
 Fail_2:
-	result = NULL;
+    result = NULL;
 Succeed:
-	assert(seqs);
-	for (i = 0; i < n; ++i)
-		Py_XDECREF(seqs[i].it);
-	PyMem_DEL(seqs);
-	return result;
+    assert(seqs);
+    for (i = 0; i < n; ++i)
+        Py_XDECREF(seqs[i].it);
+    PyMem_DEL(seqs);
+    return result;
 }
 
 PyDoc_STRVAR(map_doc,
@@ -1084,35 +1084,35 @@ the items of the sequence (or a list of tuples if more than one sequence).");
 static PyObject *
 builtin_next(PyObject *self, PyObject *args)
 {
-	PyObject *it, *res;
-	PyObject *def = NULL;
-
-	if (!PyArg_UnpackTuple(args, "next", 1, 2, &it, &def))
-		return NULL;
-	if (!PyIter_Check(it)) {
-		PyErr_Format(PyExc_TypeError,
-			"%.200s object is not an iterator",
-			it->ob_type->tp_name);
-		return NULL;
-	}
-	
-	res = (*it->ob_type->tp_iternext)(it);
-	if (res != NULL) {
-		return res;
-	} else if (def != NULL) {
-		if (PyErr_Occurred()) {
-			if (!PyErr_ExceptionMatches(PyExc_StopIteration))
-				return NULL;
-			PyErr_Clear();
-		}
-		Py_INCREF(def);
-		return def;
-	} else if (PyErr_Occurred()) {
-		return NULL;
-	} else {
-		PyErr_SetNone(PyExc_StopIteration);
-		return NULL;
-	}
+    PyObject *it, *res;
+    PyObject *def = NULL;
+
+    if (!PyArg_UnpackTuple(args, "next", 1, 2, &it, &def))
+        return NULL;
+    if (!PyIter_Check(it)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s object is not an iterator",
+            it->ob_type->tp_name);
+        return NULL;
+    }
+
+    res = (*it->ob_type->tp_iternext)(it);
+    if (res != NULL) {
+        return res;
+    } else if (def != NULL) {
+        if (PyErr_Occurred()) {
+            if (!PyErr_ExceptionMatches(PyExc_StopIteration))
+                return NULL;
+            PyErr_Clear();
+        }
+        Py_INCREF(def);
+        return def;
+    } else if (PyErr_Occurred()) {
+        return NULL;
+    } else {
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
 }
 
 PyDoc_STRVAR(next_doc,
@@ -1125,16 +1125,16 @@ is exhausted, it is returned instead of raising StopIteration.");
 static PyObject *
 builtin_setattr(PyObject *self, PyObject *args)
 {
-	PyObject *v;
-	PyObject *name;
-	PyObject *value;
-
-	if (!PyArg_UnpackTuple(args, "setattr", 3, 3, &v, &name, &value))
-		return NULL;
-	if (PyObject_SetAttr(v, name, value) != 0)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    PyObject *v;
+    PyObject *name;
+    PyObject *value;
+
+    if (!PyArg_UnpackTuple(args, "setattr", 3, 3, &v, &name, &value))
+        return NULL;
+    if (PyObject_SetAttr(v, name, value) != 0)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(setattr_doc,
@@ -1147,15 +1147,15 @@ Set a named attribute on an object; setattr(x, 'y', v) is equivalent to\n\
 static PyObject *
 builtin_delattr(PyObject *self, PyObject *args)
 {
-	PyObject *v;
-	PyObject *name;
-
-	if (!PyArg_UnpackTuple(args, "delattr", 2, 2, &v, &name))
-		return NULL;
-	if (PyObject_SetAttr(v, name, (PyObject *)NULL) != 0)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    PyObject *v;
+    PyObject *name;
+
+    if (!PyArg_UnpackTuple(args, "delattr", 2, 2, &v, &name))
+        return NULL;
+    if (PyObject_SetAttr(v, name, (PyObject *)NULL) != 0)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(delattr_doc,
@@ -1168,12 +1168,12 @@ Delete a named attribute on an object; delattr(x, 'y') is equivalent to\n\
 static PyObject *
 builtin_hash(PyObject *self, PyObject *v)
 {
-	long x;
+    long x;
 
-	x = PyObject_Hash(v);
-	if (x == -1)
-		return NULL;
-	return PyInt_FromLong(x);
+    x = PyObject_Hash(v);
+    if (x == -1)
+        return NULL;
+    return PyInt_FromLong(x);
 }
 
 PyDoc_STRVAR(hash_doc,
@@ -1186,24 +1186,24 @@ the same hash value.  The reverse is not necessarily true, but likely.");
 static PyObject *
 builtin_hex(PyObject *self, PyObject *v)
 {
-	PyNumberMethods *nb;
-	PyObject *res;
-
-	if ((nb = v->ob_type->tp_as_number) == NULL ||
-	    nb->nb_hex == NULL) {
-		PyErr_SetString(PyExc_TypeError,
-			   "hex() argument can't be converted to hex");
-		return NULL;
-	}
-	res = (*nb->nb_hex)(v);
-	if (res && !PyString_Check(res)) {
-		PyErr_Format(PyExc_TypeError,
-			     "__hex__ returned non-string (type %.200s)",
-			     res->ob_type->tp_name);
-		Py_DECREF(res);
-		return NULL;
-	}
-	return res;
+    PyNumberMethods *nb;
+    PyObject *res;
+
+    if ((nb = v->ob_type->tp_as_number) == NULL ||
+        nb->nb_hex == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                   "hex() argument can't be converted to hex");
+        return NULL;
+    }
+    res = (*nb->nb_hex)(v);
+    if (res && !PyString_Check(res)) {
+        PyErr_Format(PyExc_TypeError,
+                     "__hex__ returned non-string (type %.200s)",
+                     res->ob_type->tp_name);
+        Py_DECREF(res);
+        return NULL;
+    }
+    return res;
 }
 
 PyDoc_STRVAR(hex_doc,
@@ -1217,31 +1217,31 @@ static PyObject *builtin_raw_input(PyObject *, PyObject *);
 static PyObject *
 builtin_input(PyObject *self, PyObject *args)
 {
-	PyObject *line;
-	char *str;
-	PyObject *res;
-	PyObject *globals, *locals;
-	PyCompilerFlags cf;
-
-	line = builtin_raw_input(self, args);
-	if (line == NULL)
-		return line;
-	if (!PyArg_Parse(line, "s;embedded '\\0' in input line", &str))
-		return NULL;
-	while (*str == ' ' || *str == '\t')
-			str++;
-	globals = PyEval_GetGlobals();
-	locals = PyEval_GetLocals();
-	if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
-		if (PyDict_SetItemString(globals, "__builtins__",
-					 PyEval_GetBuiltins()) != 0)
-			return NULL;
-	}
-	cf.cf_flags = 0;
-	PyEval_MergeCompilerFlags(&cf);
-	res = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
-	Py_DECREF(line);
-	return res;
+    PyObject *line;
+    char *str;
+    PyObject *res;
+    PyObject *globals, *locals;
+    PyCompilerFlags cf;
+
+    line = builtin_raw_input(self, args);
+    if (line == NULL)
+        return line;
+    if (!PyArg_Parse(line, "s;embedded '\\0' in input line", &str))
+        return NULL;
+    while (*str == ' ' || *str == '\t')
+                    str++;
+    globals = PyEval_GetGlobals();
+    locals = PyEval_GetLocals();
+    if (PyDict_GetItemString(globals, "__builtins__") == NULL) {
+        if (PyDict_SetItemString(globals, "__builtins__",
+                                 PyEval_GetBuiltins()) != 0)
+            return NULL;
+    }
+    cf.cf_flags = 0;
+    PyEval_MergeCompilerFlags(&cf);
+    res = PyRun_StringFlags(str, Py_eval_input, globals, locals, &cf);
+    Py_DECREF(line);
+    return res;
 }
 
 PyDoc_STRVAR(input_doc,
@@ -1253,17 +1253,17 @@ Equivalent to eval(raw_input(prompt)).");
 static PyObject *
 builtin_intern(PyObject *self, PyObject *args)
 {
-	PyObject *s;
-	if (!PyArg_ParseTuple(args, "S:intern", &s))
-		return NULL;
-	if (!PyString_CheckExact(s)) {
-		PyErr_SetString(PyExc_TypeError,
-				"can't intern subclass of string");
-		return NULL;
-	}
-	Py_INCREF(s);
-	PyString_InternInPlace(&s);
-	return s;
+    PyObject *s;
+    if (!PyArg_ParseTuple(args, "S:intern", &s))
+        return NULL;
+    if (!PyString_CheckExact(s)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "can't intern subclass of string");
+        return NULL;
+    }
+    Py_INCREF(s);
+    PyString_InternInPlace(&s);
+    return s;
 }
 
 PyDoc_STRVAR(intern_doc,
@@ -1278,18 +1278,18 @@ same value.");
 static PyObject *
 builtin_iter(PyObject *self, PyObject *args)
 {
-	PyObject *v, *w = NULL;
-
-	if (!PyArg_UnpackTuple(args, "iter", 1, 2, &v, &w))
-		return NULL;
-	if (w == NULL)
-		return PyObject_GetIter(v);
-	if (!PyCallable_Check(v)) {
-		PyErr_SetString(PyExc_TypeError,
-				"iter(v, w): v must be callable");
-		return NULL;
-	}
-	return PyCallIter_New(v, w);
+    PyObject *v, *w = NULL;
+
+    if (!PyArg_UnpackTuple(args, "iter", 1, 2, &v, &w))
+        return NULL;
+    if (w == NULL)
+        return PyObject_GetIter(v);
+    if (!PyCallable_Check(v)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "iter(v, w): v must be callable");
+        return NULL;
+    }
+    return PyCallIter_New(v, w);
 }
 
 PyDoc_STRVAR(iter_doc,
@@ -1304,12 +1304,12 @@ In the second form, the callable is called until it returns the sentinel.");
 static PyObject *
 builtin_len(PyObject *self, PyObject *v)
 {
-	Py_ssize_t res;
+    Py_ssize_t res;
 
-	res = PyObject_Size(v);
-	if (res < 0 && PyErr_Occurred())
-		return NULL;
-	return PyInt_FromSsize_t(res);
+    res = PyObject_Size(v);
+    if (res < 0 && PyErr_Occurred())
+        return NULL;
+    return PyInt_FromSsize_t(res);
 }
 
 PyDoc_STRVAR(len_doc,
@@ -1321,11 +1321,11 @@ Return the number of items of a sequence or mapping.");
 static PyObject *
 builtin_locals(PyObject *self)
 {
-	PyObject *d;
+    PyObject *d;
 
-	d = PyEval_GetLocals();
-	Py_XINCREF(d);
-	return d;
+    d = PyEval_GetLocals();
+    Py_XINCREF(d);
+    return d;
 }
 
 PyDoc_STRVAR(locals_doc,
@@ -1337,96 +1337,96 @@ Update and return a dictionary containing the current scope's local variables.")
 static PyObject *
 min_max(PyObject *args, PyObject *kwds, int op)
 {
-	PyObject *v, *it, *item, *val, *maxitem, *maxval, *keyfunc=NULL;
-	const char *name = op == Py_LT ? "min" : "max";
-
-	if (PyTuple_Size(args) > 1)
-		v = args;
-	else if (!PyArg_UnpackTuple(args, (char *)name, 1, 1, &v))
-		return NULL;
-
-	if (kwds != NULL && PyDict_Check(kwds) && PyDict_Size(kwds)) {
-		keyfunc = PyDict_GetItemString(kwds, "key");
-		if (PyDict_Size(kwds)!=1  ||  keyfunc == NULL) {
-			PyErr_Format(PyExc_TypeError,
-				"%s() got an unexpected keyword argument", name);
-			return NULL;
-		}
-		Py_INCREF(keyfunc);
-	}
-
-	it = PyObject_GetIter(v);
-	if (it == NULL) {
-		Py_XDECREF(keyfunc);
-		return NULL;
-	}
-
-	maxitem = NULL; /* the result */
-	maxval = NULL;  /* the value associated with the result */
-	while (( item = PyIter_Next(it) )) {
-		/* get the value from the key function */
-		if (keyfunc != NULL) {
-			val = PyObject_CallFunctionObjArgs(keyfunc, item, NULL);
-			if (val == NULL)
-				goto Fail_it_item;
-		}
-		/* no key function; the value is the item */
-		else {
-			val = item;
-			Py_INCREF(val);
-		}
-
-		/* maximum value and item are unset; set them */
-		if (maxval == NULL) {
-			maxitem = item;
-			maxval = val;
-		}
-		/* maximum value and item are set; update them as necessary */
-		else {
-			int cmp = PyObject_RichCompareBool(val, maxval, op);
-			if (cmp < 0)
-				goto Fail_it_item_and_val;
-			else if (cmp > 0) {
-				Py_DECREF(maxval);
-				Py_DECREF(maxitem);
-				maxval = val;
-				maxitem = item;
-			}
-			else {
-				Py_DECREF(item);
-				Py_DECREF(val);
-			}
-		}
-	}
-	if (PyErr_Occurred())
-		goto Fail_it;
-	if (maxval == NULL) {
-		PyErr_Format(PyExc_ValueError,
-			     "%s() arg is an empty sequence", name);
-		assert(maxitem == NULL);
-	}
-	else
-		Py_DECREF(maxval);
-	Py_DECREF(it);
-	Py_XDECREF(keyfunc);
-	return maxitem;
+    PyObject *v, *it, *item, *val, *maxitem, *maxval, *keyfunc=NULL;
+    const char *name = op == Py_LT ? "min" : "max";
+
+    if (PyTuple_Size(args) > 1)
+        v = args;
+    else if (!PyArg_UnpackTuple(args, (char *)name, 1, 1, &v))
+        return NULL;
+
+    if (kwds != NULL && PyDict_Check(kwds) && PyDict_Size(kwds)) {
+        keyfunc = PyDict_GetItemString(kwds, "key");
+        if (PyDict_Size(kwds)!=1  ||  keyfunc == NULL) {
+            PyErr_Format(PyExc_TypeError,
+                "%s() got an unexpected keyword argument", name);
+            return NULL;
+        }
+        Py_INCREF(keyfunc);
+    }
+
+    it = PyObject_GetIter(v);
+    if (it == NULL) {
+        Py_XDECREF(keyfunc);
+        return NULL;
+    }
+
+    maxitem = NULL; /* the result */
+    maxval = NULL;  /* the value associated with the result */
+    while (( item = PyIter_Next(it) )) {
+        /* get the value from the key function */
+        if (keyfunc != NULL) {
+            val = PyObject_CallFunctionObjArgs(keyfunc, item, NULL);
+            if (val == NULL)
+                goto Fail_it_item;
+        }
+        /* no key function; the value is the item */
+        else {
+            val = item;
+            Py_INCREF(val);
+        }
+
+        /* maximum value and item are unset; set them */
+        if (maxval == NULL) {
+            maxitem = item;
+            maxval = val;
+        }
+        /* maximum value and item are set; update them as necessary */
+        else {
+            int cmp = PyObject_RichCompareBool(val, maxval, op);
+            if (cmp < 0)
+                goto Fail_it_item_and_val;
+            else if (cmp > 0) {
+                Py_DECREF(maxval);
+                Py_DECREF(maxitem);
+                maxval = val;
+                maxitem = item;
+            }
+            else {
+                Py_DECREF(item);
+                Py_DECREF(val);
+            }
+        }
+    }
+    if (PyErr_Occurred())
+        goto Fail_it;
+    if (maxval == NULL) {
+        PyErr_Format(PyExc_ValueError,
+                     "%s() arg is an empty sequence", name);
+        assert(maxitem == NULL);
+    }
+    else
+        Py_DECREF(maxval);
+    Py_DECREF(it);
+    Py_XDECREF(keyfunc);
+    return maxitem;
 
 Fail_it_item_and_val:
-	Py_DECREF(val);
+    Py_DECREF(val);
 Fail_it_item:
-	Py_DECREF(item);
+    Py_DECREF(item);
 Fail_it:
-	Py_XDECREF(maxval);
-	Py_XDECREF(maxitem);
-	Py_DECREF(it);
-	Py_XDECREF(keyfunc);
-	return NULL;
+    Py_XDECREF(maxval);
+    Py_XDECREF(maxitem);
+    Py_DECREF(it);
+    Py_XDECREF(keyfunc);
+    return NULL;
 }
 
 static PyObject *
 builtin_min(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	return min_max(args, kwds, Py_LT);
+    return min_max(args, kwds, Py_LT);
 }
 
 PyDoc_STRVAR(min_doc,
@@ -1440,7 +1440,7 @@ With two or more arguments, return the smallest argument.");
 static PyObject *
 builtin_max(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	return min_max(args, kwds, Py_GT);
+    return min_max(args, kwds, Py_GT);
 }
 
 PyDoc_STRVAR(max_doc,
@@ -1454,24 +1454,24 @@ With two or more arguments, return the largest argument.");
 static PyObject *
 builtin_oct(PyObject *self, PyObject *v)
 {
-	PyNumberMethods *nb;
-	PyObject *res;
-
-	if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
-	    nb->nb_oct == NULL) {
-		PyErr_SetString(PyExc_TypeError,
-			   "oct() argument can't be converted to oct");
-		return NULL;
-	}
-	res = (*nb->nb_oct)(v);
-	if (res && !PyString_Check(res)) {
-		PyErr_Format(PyExc_TypeError,
-			     "__oct__ returned non-string (type %.200s)",
-			     res->ob_type->tp_name);
-		Py_DECREF(res);
-		return NULL;
-	}
-	return res;
+    PyNumberMethods *nb;
+    PyObject *res;
+
+    if (v == NULL || (nb = v->ob_type->tp_as_number) == NULL ||
+        nb->nb_oct == NULL) {
+        PyErr_SetString(PyExc_TypeError,
+                   "oct() argument can't be converted to oct");
+        return NULL;
+    }
+    res = (*nb->nb_oct)(v);
+    if (res && !PyString_Check(res)) {
+        PyErr_Format(PyExc_TypeError,
+                     "__oct__ returned non-string (type %.200s)",
+                     res->ob_type->tp_name);
+        Py_DECREF(res);
+        return NULL;
+    }
+    return res;
 }
 
 PyDoc_STRVAR(oct_doc,
@@ -1483,7 +1483,7 @@ Return the octal representation of an integer or long integer.");
 static PyObject *
 builtin_open(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	return PyObject_Call((PyObject*)&PyFile_Type, args, kwds);
+    return PyObject_Call((PyObject*)&PyFile_Type, args, kwds);
 }
 
 PyDoc_STRVAR(open_doc,
@@ -1496,42 +1496,42 @@ preferred way to open a file.  See file.__doc__ for further information.");
 static PyObject *
 builtin_ord(PyObject *self, PyObject* obj)
 {
-	long ord;
-	Py_ssize_t size;
-
-	if (PyString_Check(obj)) {
-		size = PyString_GET_SIZE(obj);
-		if (size == 1) {
-			ord = (long)((unsigned char)*PyString_AS_STRING(obj));
-			return PyInt_FromLong(ord);
-		}
-	} else if (PyByteArray_Check(obj)) {
-		size = PyByteArray_GET_SIZE(obj);
-		if (size == 1) {
-			ord = (long)((unsigned char)*PyByteArray_AS_STRING(obj));
-			return PyInt_FromLong(ord);
-		}
+    long ord;
+    Py_ssize_t size;
+
+    if (PyString_Check(obj)) {
+        size = PyString_GET_SIZE(obj);
+        if (size == 1) {
+            ord = (long)((unsigned char)*PyString_AS_STRING(obj));
+            return PyInt_FromLong(ord);
+        }
+    } else if (PyByteArray_Check(obj)) {
+        size = PyByteArray_GET_SIZE(obj);
+        if (size == 1) {
+            ord = (long)((unsigned char)*PyByteArray_AS_STRING(obj));
+            return PyInt_FromLong(ord);
+        }
 
 #ifdef Py_USING_UNICODE
-	} else if (PyUnicode_Check(obj)) {
-		size = PyUnicode_GET_SIZE(obj);
-		if (size == 1) {
-			ord = (long)*PyUnicode_AS_UNICODE(obj);
-			return PyInt_FromLong(ord);
-		}
+    } else if (PyUnicode_Check(obj)) {
+        size = PyUnicode_GET_SIZE(obj);
+        if (size == 1) {
+            ord = (long)*PyUnicode_AS_UNICODE(obj);
+            return PyInt_FromLong(ord);
+        }
 #endif
-	} else {
-		PyErr_Format(PyExc_TypeError,
-			     "ord() expected string of length 1, but " \
-			     "%.200s found", obj->ob_type->tp_name);
-		return NULL;
-	}
-
-	PyErr_Format(PyExc_TypeError,
-		     "ord() expected a character, "
-		     "but string of length %zd found",
-		     size);
-	return NULL;
+    } else {
+        PyErr_Format(PyExc_TypeError,
+                     "ord() expected string of length 1, but " \
+                     "%.200s found", obj->ob_type->tp_name);
+        return NULL;
+    }
+
+    PyErr_Format(PyExc_TypeError,
+                 "ord() expected a character, "
+                 "but string of length %zd found",
+                 size);
+    return NULL;
 }
 
 PyDoc_STRVAR(ord_doc,
@@ -1543,11 +1543,11 @@ Return the integer ordinal of a one-character string.");
 static PyObject *
 builtin_pow(PyObject *self, PyObject *args)
 {
-	PyObject *v, *w, *z = Py_None;
+    PyObject *v, *w, *z = Py_None;
 
-	if (!PyArg_UnpackTuple(args, "pow", 2, 3, &v, &w, &z))
-		return NULL;
-	return PyNumber_Power(v, w, z);
+    if (!PyArg_UnpackTuple(args, "pow", 2, 3, &v, &w, &z))
+        return NULL;
+    return PyNumber_Power(v, w, z);
 }
 
 PyDoc_STRVAR(pow_doc,
@@ -1560,120 +1560,120 @@ equivalent to (x**y) % z, but may be more efficient (e.g. for longs).");
 static PyObject *
 builtin_print(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	static char *kwlist[] = {"sep", "end", "file", 0};
-	static PyObject *dummy_args = NULL;
-	static PyObject *unicode_newline = NULL, *unicode_space = NULL;
-	static PyObject *str_newline = NULL, *str_space = NULL;
-	PyObject *newline, *space;
-	PyObject *sep = NULL, *end = NULL, *file = NULL;
-	int i, err, use_unicode = 0;
-
-	if (dummy_args == NULL) {
-		if (!(dummy_args = PyTuple_New(0)))
-			return NULL;
-	}
-	if (str_newline == NULL) {
-		str_newline = PyString_FromString("\n");
-		if (str_newline == NULL)
-			return NULL;
-		str_space = PyString_FromString(" ");
-		if (str_space == NULL) {
-			Py_CLEAR(str_newline);
-			return NULL;
-		}
-		unicode_newline = PyUnicode_FromString("\n");
-		if (unicode_newline == NULL) {
-			Py_CLEAR(str_newline);
-			Py_CLEAR(str_space);
-			return NULL;
-		}
-		unicode_space = PyUnicode_FromString(" ");
-		if (unicode_space == NULL) {
-			Py_CLEAR(str_newline);
-			Py_CLEAR(str_space);
-			Py_CLEAR(unicode_space);
-			return NULL;
-		}
-	}
-	if (!PyArg_ParseTupleAndKeywords(dummy_args, kwds, "|OOO:print",
-					 kwlist, &sep, &end, &file))
-		return NULL;
-	if (file == NULL || file == Py_None) {
-		file = PySys_GetObject("stdout");
-		/* sys.stdout may be None when FILE* stdout isn't connected */
-		if (file == Py_None)
-			Py_RETURN_NONE;
-	}
-	if (sep == Py_None) {
-		sep = NULL;
-	}
-	else if (sep) {
-		if (PyUnicode_Check(sep)) {
-			use_unicode = 1;
-		}
-		else if (!PyString_Check(sep)) {
-			PyErr_Format(PyExc_TypeError,
-				     "sep must be None, str or unicode, not %.200s",
-				     sep->ob_type->tp_name);
-			return NULL;
-		}
-	}
-	if (end == Py_None)
-		end = NULL;
-	else if (end) {
-		if (PyUnicode_Check(end)) {
-			use_unicode = 1;
-		}
-		else if (!PyString_Check(end)) {
-			PyErr_Format(PyExc_TypeError,
-				     "end must be None, str or unicode, not %.200s",
-				     end->ob_type->tp_name);
-			return NULL;
-		}
-	}
-
-	if (!use_unicode) {
-		for (i = 0; i < PyTuple_Size(args); i++) {
-			if (PyUnicode_Check(PyTuple_GET_ITEM(args, i))) {
-				use_unicode = 1;
-				break;
-			}
-		}
-	}
-	if (use_unicode) {
-		newline = unicode_newline;
-		space = unicode_space;
-	}
-	else {
-		newline = str_newline;
-		space = str_space;
-	}
-
-	for (i = 0; i < PyTuple_Size(args); i++) {
-		if (i > 0) {
-			if (sep == NULL)
-				err = PyFile_WriteObject(space, file,
-							 Py_PRINT_RAW);
-			else
-				err = PyFile_WriteObject(sep, file,
-							 Py_PRINT_RAW);
-			if (err)
-				return NULL;
-		}
-		err = PyFile_WriteObject(PyTuple_GetItem(args, i), file,
-					 Py_PRINT_RAW);
-		if (err)
-			return NULL;
-	}
-
-	if (end == NULL)
-		err = PyFile_WriteObject(newline, file, Py_PRINT_RAW);
-	else
-		err = PyFile_WriteObject(end, file, Py_PRINT_RAW);
-	if (err)
-		return NULL;
-
-	Py_RETURN_NONE;
+    static char *kwlist[] = {"sep", "end", "file", 0};
+    static PyObject *dummy_args = NULL;
+    static PyObject *unicode_newline = NULL, *unicode_space = NULL;
+    static PyObject *str_newline = NULL, *str_space = NULL;
+    PyObject *newline, *space;
+    PyObject *sep = NULL, *end = NULL, *file = NULL;
+    int i, err, use_unicode = 0;
+
+    if (dummy_args == NULL) {
+        if (!(dummy_args = PyTuple_New(0)))
+            return NULL;
+    }
+    if (str_newline == NULL) {
+        str_newline = PyString_FromString("\n");
+        if (str_newline == NULL)
+            return NULL;
+        str_space = PyString_FromString(" ");
+        if (str_space == NULL) {
+            Py_CLEAR(str_newline);
+            return NULL;
+        }
+        unicode_newline = PyUnicode_FromString("\n");
+        if (unicode_newline == NULL) {
+            Py_CLEAR(str_newline);
+            Py_CLEAR(str_space);
+            return NULL;
+        }
+        unicode_space = PyUnicode_FromString(" ");
+        if (unicode_space == NULL) {
+            Py_CLEAR(str_newline);
+            Py_CLEAR(str_space);
+            Py_CLEAR(unicode_space);
+            return NULL;
+        }
+    }
+    if (!PyArg_ParseTupleAndKeywords(dummy_args, kwds, "|OOO:print",
+                                     kwlist, &sep, &end, &file))
+        return NULL;
+    if (file == NULL || file == Py_None) {
+        file = PySys_GetObject("stdout");
+        /* sys.stdout may be None when FILE* stdout isn't connected */
+        if (file == Py_None)
+            Py_RETURN_NONE;
+    }
+    if (sep == Py_None) {
+        sep = NULL;
+    }
+    else if (sep) {
+        if (PyUnicode_Check(sep)) {
+            use_unicode = 1;
+        }
+        else if (!PyString_Check(sep)) {
+            PyErr_Format(PyExc_TypeError,
+                         "sep must be None, str or unicode, not %.200s",
+                         sep->ob_type->tp_name);
+            return NULL;
+        }
+    }
+    if (end == Py_None)
+        end = NULL;
+    else if (end) {
+        if (PyUnicode_Check(end)) {
+            use_unicode = 1;
+        }
+        else if (!PyString_Check(end)) {
+            PyErr_Format(PyExc_TypeError,
+                         "end must be None, str or unicode, not %.200s",
+                         end->ob_type->tp_name);
+            return NULL;
+        }
+    }
+
+    if (!use_unicode) {
+        for (i = 0; i < PyTuple_Size(args); i++) {
+            if (PyUnicode_Check(PyTuple_GET_ITEM(args, i))) {
+                use_unicode = 1;
+                break;
+            }
+        }
+    }
+    if (use_unicode) {
+        newline = unicode_newline;
+        space = unicode_space;
+    }
+    else {
+        newline = str_newline;
+        space = str_space;
+    }
+
+    for (i = 0; i < PyTuple_Size(args); i++) {
+        if (i > 0) {
+            if (sep == NULL)
+                err = PyFile_WriteObject(space, file,
+                                         Py_PRINT_RAW);
+            else
+                err = PyFile_WriteObject(sep, file,
+                                         Py_PRINT_RAW);
+            if (err)
+                return NULL;
+        }
+        err = PyFile_WriteObject(PyTuple_GetItem(args, i), file,
+                                 Py_PRINT_RAW);
+        if (err)
+            return NULL;
+    }
+
+    if (end == NULL)
+        err = PyFile_WriteObject(newline, file, Py_PRINT_RAW);
+    else
+        err = PyFile_WriteObject(end, file, Py_PRINT_RAW);
+    if (err)
+        return NULL;
+
+    Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(print_doc,
@@ -1695,55 +1695,55 @@ end:  string appended after the last value, default a newline.");
 static long
 get_len_of_range_longs(PyObject *lo, PyObject *hi, PyObject *step)
 {
-	/* -------------------------------------------------------------
-	Algorithm is equal to that of get_len_of_range(), but it operates
-	on PyObjects (which are assumed to be PyLong or PyInt objects).
-	---------------------------------------------------------------*/
-	long n;
-	PyObject *diff = NULL;
-	PyObject *one = NULL;
-	PyObject *tmp1 = NULL, *tmp2 = NULL, *tmp3 = NULL;
-		/* holds sub-expression evaluations */
-
-	/* if (lo >= hi), return length of 0. */
-	if (PyObject_Compare(lo, hi) >= 0)
-		return 0;
-
-	if ((one = PyLong_FromLong(1L)) == NULL)
-		goto Fail;
-
-	if ((tmp1 = PyNumber_Subtract(hi, lo)) == NULL)
-		goto Fail;
-
-	if ((diff = PyNumber_Subtract(tmp1, one)) == NULL)
-		goto Fail;
-
-	if ((tmp2 = PyNumber_FloorDivide(diff, step)) == NULL)
-		goto Fail;
-
-	if ((tmp3 = PyNumber_Add(tmp2, one)) == NULL)
-		goto Fail;
-
-	n = PyLong_AsLong(tmp3);
-	if (PyErr_Occurred()) {  /* Check for Overflow */
-		PyErr_Clear();
-		goto Fail;
-	}
-
-	Py_DECREF(tmp3);
-	Py_DECREF(tmp2);
-	Py_DECREF(diff);
-	Py_DECREF(tmp1);
-	Py_DECREF(one);
-	return n;
+    /* -------------------------------------------------------------
+    Algorithm is equal to that of get_len_of_range(), but it operates
+    on PyObjects (which are assumed to be PyLong or PyInt objects).
+    ---------------------------------------------------------------*/
+    long n;
+    PyObject *diff = NULL;
+    PyObject *one = NULL;
+    PyObject *tmp1 = NULL, *tmp2 = NULL, *tmp3 = NULL;
+        /* holds sub-expression evaluations */
+
+    /* if (lo >= hi), return length of 0. */
+    if (PyObject_Compare(lo, hi) >= 0)
+        return 0;
+
+    if ((one = PyLong_FromLong(1L)) == NULL)
+        goto Fail;
+
+    if ((tmp1 = PyNumber_Subtract(hi, lo)) == NULL)
+        goto Fail;
+
+    if ((diff = PyNumber_Subtract(tmp1, one)) == NULL)
+        goto Fail;
+
+    if ((tmp2 = PyNumber_FloorDivide(diff, step)) == NULL)
+        goto Fail;
+
+    if ((tmp3 = PyNumber_Add(tmp2, one)) == NULL)
+        goto Fail;
+
+    n = PyLong_AsLong(tmp3);
+    if (PyErr_Occurred()) {  /* Check for Overflow */
+        PyErr_Clear();
+        goto Fail;
+    }
+
+    Py_DECREF(tmp3);
+    Py_DECREF(tmp2);
+    Py_DECREF(diff);
+    Py_DECREF(tmp1);
+    Py_DECREF(one);
+    return n;
 
   Fail:
-	Py_XDECREF(tmp3);
-	Py_XDECREF(tmp2);
-	Py_XDECREF(diff);
-	Py_XDECREF(tmp1);
-	Py_XDECREF(one);
-	return -1;
+    Py_XDECREF(tmp3);
+    Py_XDECREF(tmp2);
+    Py_XDECREF(diff);
+    Py_XDECREF(tmp1);
+    Py_XDECREF(one);
+    return -1;
 }
 
 /* Helper function for handle_range_longs.  If arg is int or long
@@ -1756,29 +1756,29 @@ get_len_of_range_longs(PyObject *lo, PyObject *hi, PyObject *step)
 static PyObject *
 get_range_long_argument(PyObject *arg, const char *name)
 {
-	PyObject *v;
-	PyNumberMethods *nb;
-	if (PyInt_Check(arg) || PyLong_Check(arg)) {
-		Py_INCREF(arg);
-		return arg;
-	}
-	if (PyFloat_Check(arg) ||
-	    (nb = Py_TYPE(arg)->tp_as_number) == NULL ||
-	    nb->nb_int == NULL) {
-		PyErr_Format(PyExc_TypeError,
-			     "range() integer %s argument expected, got %s.",
-			     name, arg->ob_type->tp_name);
-		return NULL;
-	}
-	v = nb->nb_int(arg);
-	if (v == NULL)
-		return NULL;
-	if (PyInt_Check(v) || PyLong_Check(v))
-		return v;
-	Py_DECREF(v);
-	PyErr_SetString(PyExc_TypeError,
-			"__int__ should return int object");
-	return NULL;
+    PyObject *v;
+    PyNumberMethods *nb;
+    if (PyInt_Check(arg) || PyLong_Check(arg)) {
+        Py_INCREF(arg);
+        return arg;
+    }
+    if (PyFloat_Check(arg) ||
+        (nb = Py_TYPE(arg)->tp_as_number) == NULL ||
+        nb->nb_int == NULL) {
+        PyErr_Format(PyExc_TypeError,
+                     "range() integer %s argument expected, got %s.",
+                     name, arg->ob_type->tp_name);
+        return NULL;
+    }
+    v = nb->nb_int(arg);
+    if (v == NULL)
+        return NULL;
+    if (PyInt_Check(v) || PyLong_Check(v))
+        return v;
+    Py_DECREF(v);
+    PyErr_SetString(PyExc_TypeError,
+                    "__int__ should return int object");
+    return NULL;
 }
 
 /* An extension of builtin_range() that handles the case when PyLong
@@ -1786,129 +1786,129 @@ get_range_long_argument(PyObject *arg, const char *name)
 static PyObject *
 handle_range_longs(PyObject *self, PyObject *args)
 {
-	PyObject *ilow = NULL;
-	PyObject *ihigh = NULL;
-	PyObject *istep = NULL;
-
-	PyObject *low = NULL;
-	PyObject *high = NULL;
-	PyObject *step = NULL;
-
-	PyObject *curnum = NULL;
-	PyObject *v = NULL;
-	long bign;
-	Py_ssize_t i, n;
-	int cmp_result;
-
-	PyObject *zero = PyLong_FromLong(0);
-
-	if (zero == NULL)
-		return NULL;
-
-	if (!PyArg_UnpackTuple(args, "range", 1, 3, &ilow, &ihigh, &istep)) {
-		Py_DECREF(zero);
-		return NULL;
-	}
-
-	/* Figure out which way we were called, supply defaults, and be
-	 * sure to incref everything so that the decrefs at the end
-	 * are correct. NB: ilow, ihigh and istep are borrowed references.
-	 */
-	assert(ilow != NULL);
-	if (ihigh == NULL) {
-		/* only 1 arg -- it's the upper limit */
-		ihigh = ilow;
-		ilow = NULL;
-	}
-
-	/* convert ihigh if necessary */
-	assert(ihigh != NULL);
-	high = get_range_long_argument(ihigh, "end");
-	if (high == NULL)
-		goto Fail;
-
-	/* ihigh correct now; do ilow */
-	if (ilow == NULL) {
-		Py_INCREF(zero);
-		low = zero;
-	}
-	else {
-		low = get_range_long_argument(ilow, "start");
-		if (low == NULL)
-			goto Fail;
-	}
-
-	/* ilow and ihigh correct now; do istep */
-	if (istep == NULL)
-		step = PyLong_FromLong(1);
-	else
-		step = get_range_long_argument(istep, "step");
-	if (step == NULL)
-		goto Fail;
-
-	if (PyObject_Cmp(step, zero, &cmp_result) == -1)
-		goto Fail;
-
-	if (cmp_result == 0) {
-		PyErr_SetString(PyExc_ValueError,
-				"range() step argument must not be zero");
-		goto Fail;
-	}
-
-	if (cmp_result > 0)
-		bign = get_len_of_range_longs(low, high, step);
-	else {
-		PyObject *neg_step = PyNumber_Negative(step);
-		if (neg_step == NULL)
-			goto Fail;
-		bign = get_len_of_range_longs(high, low, neg_step);
-		Py_DECREF(neg_step);
-	}
-
-	n = (Py_ssize_t)bign;
-	if (bign < 0 || (long)n != bign) {
-		PyErr_SetString(PyExc_OverflowError,
-				"range() result has too many items");
-		goto Fail;
-	}
-
-	v = PyList_New(n);
-	if (v == NULL)
-		goto Fail;
-
-	curnum = low;
-	Py_INCREF(curnum);
-
-	for (i = 0; i < n; i++) {
-		PyObject *w = PyNumber_Long(curnum);
-		PyObject *tmp_num;
-		if (w == NULL)
-			goto Fail;
-
-		PyList_SET_ITEM(v, i, w);
-
-		tmp_num = PyNumber_Add(curnum, step);
-		if (tmp_num == NULL)
-			goto Fail;
-
-		Py_DECREF(curnum);
-		curnum = tmp_num;
-	}
-	Py_DECREF(low);
-	Py_DECREF(high);
-	Py_DECREF(step);
-	Py_DECREF(zero);
-	Py_DECREF(curnum);
-	return v;
+    PyObject *ilow = NULL;
+    PyObject *ihigh = NULL;
+    PyObject *istep = NULL;
+
+    PyObject *low = NULL;
+    PyObject *high = NULL;
+    PyObject *step = NULL;
+
+    PyObject *curnum = NULL;
+    PyObject *v = NULL;
+    long bign;
+    Py_ssize_t i, n;
+    int cmp_result;
+
+    PyObject *zero = PyLong_FromLong(0);
+
+    if (zero == NULL)
+        return NULL;
+
+    if (!PyArg_UnpackTuple(args, "range", 1, 3, &ilow, &ihigh, &istep)) {
+        Py_DECREF(zero);
+        return NULL;
+    }
+
+    /* Figure out which way we were called, supply defaults, and be
+     * sure to incref everything so that the decrefs at the end
+     * are correct. NB: ilow, ihigh and istep are borrowed references.
+     */
+    assert(ilow != NULL);
+    if (ihigh == NULL) {
+        /* only 1 arg -- it's the upper limit */
+        ihigh = ilow;
+        ilow = NULL;
+    }
+
+    /* convert ihigh if necessary */
+    assert(ihigh != NULL);
+    high = get_range_long_argument(ihigh, "end");
+    if (high == NULL)
+        goto Fail;
+
+    /* ihigh correct now; do ilow */
+    if (ilow == NULL) {
+        Py_INCREF(zero);
+        low = zero;
+    }
+    else {
+        low = get_range_long_argument(ilow, "start");
+        if (low == NULL)
+            goto Fail;
+    }
+
+    /* ilow and ihigh correct now; do istep */
+    if (istep == NULL)
+        step = PyLong_FromLong(1);
+    else
+        step = get_range_long_argument(istep, "step");
+    if (step == NULL)
+        goto Fail;
+
+    if (PyObject_Cmp(step, zero, &cmp_result) == -1)
+        goto Fail;
+
+    if (cmp_result == 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "range() step argument must not be zero");
+        goto Fail;
+    }
+
+    if (cmp_result > 0)
+        bign = get_len_of_range_longs(low, high, step);
+    else {
+        PyObject *neg_step = PyNumber_Negative(step);
+        if (neg_step == NULL)
+            goto Fail;
+        bign = get_len_of_range_longs(high, low, neg_step);
+        Py_DECREF(neg_step);
+    }
+
+    n = (Py_ssize_t)bign;
+    if (bign < 0 || (long)n != bign) {
+        PyErr_SetString(PyExc_OverflowError,
+                        "range() result has too many items");
+        goto Fail;
+    }
+
+    v = PyList_New(n);
+    if (v == NULL)
+        goto Fail;
+
+    curnum = low;
+    Py_INCREF(curnum);
+
+    for (i = 0; i < n; i++) {
+        PyObject *w = PyNumber_Long(curnum);
+        PyObject *tmp_num;
+        if (w == NULL)
+            goto Fail;
+
+        PyList_SET_ITEM(v, i, w);
+
+        tmp_num = PyNumber_Add(curnum, step);
+        if (tmp_num == NULL)
+            goto Fail;
+
+        Py_DECREF(curnum);
+        curnum = tmp_num;
+    }
+    Py_DECREF(low);
+    Py_DECREF(high);
+    Py_DECREF(step);
+    Py_DECREF(zero);
+    Py_DECREF(curnum);
+    return v;
 
   Fail:
-	Py_XDECREF(low);
-	Py_XDECREF(high);
-	Py_XDECREF(step);
-	Py_DECREF(zero);
-	Py_XDECREF(curnum);
-	Py_XDECREF(v);
-	return NULL;
+    Py_XDECREF(low);
+    Py_XDECREF(high);
+    Py_XDECREF(step);
+    Py_DECREF(zero);
+    Py_XDECREF(curnum);
+    Py_XDECREF(v);
+    return NULL;
 }
 
 /* Return number of items in range/xrange (lo, hi, step).  step > 0
@@ -1918,81 +1918,81 @@ handle_range_longs(PyObject *self, PyObject *args)
 static long
 get_len_of_range(long lo, long hi, long step)
 {
-	/* -------------------------------------------------------------
-	If lo >= hi, the range is empty.
-	Else if n values are in the range, the last one is
-	lo + (n-1)*step, which must be <= hi-1.  Rearranging,
-	n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
-	the proper value.  Since lo < hi in this case, hi-lo-1 >= 0, so
-	the RHS is non-negative and so truncation is the same as the
-	floor.  Letting M be the largest positive long, the worst case
-	for the RHS numerator is hi=M, lo=-M-1, and then
-	hi-lo-1 = M-(-M-1)-1 = 2*M.  Therefore unsigned long has enough
-	precision to compute the RHS exactly.
-	---------------------------------------------------------------*/
-	long n = 0;
-	if (lo < hi) {
-		unsigned long uhi = (unsigned long)hi;
-		unsigned long ulo = (unsigned long)lo;
-		unsigned long diff = uhi - ulo - 1;
-		n = (long)(diff / (unsigned long)step + 1);
-	}
-	return n;
+    /* -------------------------------------------------------------
+    If lo >= hi, the range is empty.
+    Else if n values are in the range, the last one is
+    lo + (n-1)*step, which must be <= hi-1.  Rearranging,
+    n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
+    the proper value.  Since lo < hi in this case, hi-lo-1 >= 0, so
+    the RHS is non-negative and so truncation is the same as the
+    floor.  Letting M be the largest positive long, the worst case
+    for the RHS numerator is hi=M, lo=-M-1, and then
+    hi-lo-1 = M-(-M-1)-1 = 2*M.  Therefore unsigned long has enough
+    precision to compute the RHS exactly.
+    ---------------------------------------------------------------*/
+    long n = 0;
+    if (lo < hi) {
+        unsigned long uhi = (unsigned long)hi;
+        unsigned long ulo = (unsigned long)lo;
+        unsigned long diff = uhi - ulo - 1;
+        n = (long)(diff / (unsigned long)step + 1);
+    }
+    return n;
 }
 
 static PyObject *
 builtin_range(PyObject *self, PyObject *args)
 {
-	long ilow = 0, ihigh = 0, istep = 1;
-	long bign;
-	Py_ssize_t i, n;
-
-	PyObject *v;
-
-	if (PyTuple_Size(args) <= 1) {
-		if (!PyArg_ParseTuple(args,
-				"l;range() requires 1-3 int arguments",
-				&ihigh)) {
-			PyErr_Clear();
-			return handle_range_longs(self, args);
-		}
-	}
-	else {
-		if (!PyArg_ParseTuple(args,
-				"ll|l;range() requires 1-3 int arguments",
-				&ilow, &ihigh, &istep)) {
-			PyErr_Clear();
-			return handle_range_longs(self, args);
-		}
-	}
-	if (istep == 0) {
-		PyErr_SetString(PyExc_ValueError,
-				"range() step argument must not be zero");
-		return NULL;
-	}
-	if (istep > 0)
-		bign = get_len_of_range(ilow, ihigh, istep);
-	else
-		bign = get_len_of_range(ihigh, ilow, -istep);
-	n = (Py_ssize_t)bign;
-	if (bign < 0 || (long)n != bign) {
-		PyErr_SetString(PyExc_OverflowError,
-				"range() result has too many items");
-		return NULL;
-	}
-	v = PyList_New(n);
-	if (v == NULL)
-		return NULL;
-	for (i = 0; i < n; i++) {
-		PyObject *w = PyInt_FromLong(ilow);
-		if (w == NULL) {
-			Py_DECREF(v);
-			return NULL;
-		}
-		PyList_SET_ITEM(v, i, w);
-		ilow += istep;
-	}
-	return v;
+    long ilow = 0, ihigh = 0, istep = 1;
+    long bign;
+    Py_ssize_t i, n;
+
+    PyObject *v;
+
+    if (PyTuple_Size(args) <= 1) {
+        if (!PyArg_ParseTuple(args,
+                        "l;range() requires 1-3 int arguments",
+                        &ihigh)) {
+            PyErr_Clear();
+            return handle_range_longs(self, args);
+        }
+    }
+    else {
+        if (!PyArg_ParseTuple(args,
+                        "ll|l;range() requires 1-3 int arguments",
+                        &ilow, &ihigh, &istep)) {
+            PyErr_Clear();
+            return handle_range_longs(self, args);
+        }
+    }
+    if (istep == 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "range() step argument must not be zero");
+        return NULL;
+    }
+    if (istep > 0)
+        bign = get_len_of_range(ilow, ihigh, istep);
+    else
+        bign = get_len_of_range(ihigh, ilow, -istep);
+    n = (Py_ssize_t)bign;
+    if (bign < 0 || (long)n != bign) {
+        PyErr_SetString(PyExc_OverflowError,
+                        "range() result has too many items");
+        return NULL;
+    }
+    v = PyList_New(n);
+    if (v == NULL)
+        return NULL;
+    for (i = 0; i < n; i++) {
+        PyObject *w = PyInt_FromLong(ilow);
+        if (w == NULL) {
+            Py_DECREF(v);
+            return NULL;
+        }
+        PyList_SET_ITEM(v, i, w);
+        ilow += istep;
+    }
+    return v;
 }
 
 PyDoc_STRVAR(range_doc,
@@ -2008,75 +2008,75 @@ These are exactly the valid indices for a list of 4 elements.");
 static PyObject *
 builtin_raw_input(PyObject *self, PyObject *args)
 {
-	PyObject *v = NULL;
-	PyObject *fin = PySys_GetObject("stdin");
-	PyObject *fout = PySys_GetObject("stdout");
-
-	if (!PyArg_UnpackTuple(args, "[raw_]input", 0, 1, &v))
-		return NULL;
-
-	if (fin == NULL) {
-		PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdin");
-		return NULL;
-	}
-	if (fout == NULL) {
-		PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdout");
-		return NULL;
-	}
-	if (PyFile_SoftSpace(fout, 0)) {
-		if (PyFile_WriteString(" ", fout) != 0)
-			return NULL;
-	}
-	if (PyFile_AsFile(fin) && PyFile_AsFile(fout)
-            && isatty(fileno(PyFile_AsFile(fin)))
-            && isatty(fileno(PyFile_AsFile(fout)))) {
-		PyObject *po;
-		char *prompt;
-		char *s;
-		PyObject *result;
-		if (v != NULL) {
-			po = PyObject_Str(v);
-			if (po == NULL)
-				return NULL;
-			prompt = PyString_AsString(po);
-			if (prompt == NULL)
-				return NULL;
-		}
-		else {
-			po = NULL;
-			prompt = "";
-		}
-		s = PyOS_Readline(PyFile_AsFile(fin), PyFile_AsFile(fout),
-                                  prompt);
-		Py_XDECREF(po);
-		if (s == NULL) {
-			if (!PyErr_Occurred())
-				PyErr_SetNone(PyExc_KeyboardInterrupt);
-			return NULL;
-		}
-		if (*s == '\0') {
-			PyErr_SetNone(PyExc_EOFError);
-			result = NULL;
-		}
-		else { /* strip trailing '\n' */
-			size_t len = strlen(s);
-			if (len > PY_SSIZE_T_MAX) {
-				PyErr_SetString(PyExc_OverflowError,
-						"[raw_]input: input too long");
-				result = NULL;
-			}
-			else {
-				result = PyString_FromStringAndSize(s, len-1);
-			}
-		}
-		PyMem_FREE(s);
-		return result;
-	}
-	if (v != NULL) {
-		if (PyFile_WriteObject(v, fout, Py_PRINT_RAW) != 0)
-			return NULL;
-	}
-	return PyFile_GetLine(fin, -1);
+    PyObject *v = NULL;
+    PyObject *fin = PySys_GetObject("stdin");
+    PyObject *fout = PySys_GetObject("stdout");
+
+    if (!PyArg_UnpackTuple(args, "[raw_]input", 0, 1, &v))
+        return NULL;
+
+    if (fin == NULL) {
+        PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdin");
+        return NULL;
+    }
+    if (fout == NULL) {
+        PyErr_SetString(PyExc_RuntimeError, "[raw_]input: lost sys.stdout");
+        return NULL;
+    }
+    if (PyFile_SoftSpace(fout, 0)) {
+        if (PyFile_WriteString(" ", fout) != 0)
+            return NULL;
+    }
+    if (PyFile_AsFile(fin) && PyFile_AsFile(fout)
+        && isatty(fileno(PyFile_AsFile(fin)))
+        && isatty(fileno(PyFile_AsFile(fout)))) {
+        PyObject *po;
+        char *prompt;
+        char *s;
+        PyObject *result;
+        if (v != NULL) {
+            po = PyObject_Str(v);
+            if (po == NULL)
+                return NULL;
+            prompt = PyString_AsString(po);
+            if (prompt == NULL)
+                return NULL;
+        }
+        else {
+            po = NULL;
+            prompt = "";
+        }
+        s = PyOS_Readline(PyFile_AsFile(fin), PyFile_AsFile(fout),
+                          prompt);
+        Py_XDECREF(po);
+        if (s == NULL) {
+            if (!PyErr_Occurred())
+                PyErr_SetNone(PyExc_KeyboardInterrupt);
+            return NULL;
+        }
+        if (*s == '\0') {
+            PyErr_SetNone(PyExc_EOFError);
+            result = NULL;
+        }
+        else { /* strip trailing '\n' */
+            size_t len = strlen(s);
+            if (len > PY_SSIZE_T_MAX) {
+                PyErr_SetString(PyExc_OverflowError,
+                                "[raw_]input: input too long");
+                result = NULL;
+            }
+            else {
+                result = PyString_FromStringAndSize(s, len-1);
+            }
+        }
+        PyMem_FREE(s);
+        return result;
+    }
+    if (v != NULL) {
+        if (PyFile_WriteObject(v, fout, Py_PRINT_RAW) != 0)
+            return NULL;
+    }
+    return PyFile_GetLine(fin, -1);
 }
 
 PyDoc_STRVAR(raw_input_doc,
@@ -2091,22 +2091,22 @@ is printed without a trailing newline before reading.");
 static PyObject *
 builtin_reduce(PyObject *self, PyObject *args)
 {
-	static PyObject *functools_reduce = NULL;
-
-	if (PyErr_WarnPy3k("reduce() not supported in 3.x; "
-			   "use functools.reduce()", 1) < 0)
-		return NULL;
-
-	if (functools_reduce == NULL) {
-		PyObject *functools = PyImport_ImportModule("functools");
-		if (functools == NULL)
-			return NULL;
-		functools_reduce = PyObject_GetAttrString(functools, "reduce");
-		Py_DECREF(functools);
-		if (functools_reduce == NULL)
-			return NULL;
-	}
-	return PyObject_Call(functools_reduce, args, NULL);
+    static PyObject *functools_reduce = NULL;
+
+    if (PyErr_WarnPy3k("reduce() not supported in 3.x; "
+                       "use functools.reduce()", 1) < 0)
+        return NULL;
+
+    if (functools_reduce == NULL) {
+        PyObject *functools = PyImport_ImportModule("functools");
+        if (functools == NULL)
+            return NULL;
+        functools_reduce = PyObject_GetAttrString(functools, "reduce");
+        Py_DECREF(functools);
+        if (functools_reduce == NULL)
+            return NULL;
+    }
+    return PyObject_Call(functools_reduce, args, NULL);
 }
 
 PyDoc_STRVAR(reduce_doc,
@@ -2123,11 +2123,11 @@ sequence is empty.");
 static PyObject *
 builtin_reload(PyObject *self, PyObject *v)
 {
-	if (PyErr_WarnPy3k("In 3.x, reload() is renamed to imp.reload()",
-			   1) < 0)
-		return NULL;
+    if (PyErr_WarnPy3k("In 3.x, reload() is renamed to imp.reload()",
+                       1) < 0)
+        return NULL;
 
-	return PyImport_ReloadModule(v);
+    return PyImport_ReloadModule(v);
 }
 
 PyDoc_STRVAR(reload_doc,
@@ -2139,7 +2139,7 @@ Reload the module.  The module must have been successfully imported before.");
 static PyObject *
 builtin_repr(PyObject *self, PyObject *v)
 {
-	return PyObject_Repr(v);
+    return PyObject_Repr(v);
 }
 
 PyDoc_STRVAR(repr_doc,
@@ -2152,45 +2152,45 @@ For most object types, eval(repr(object)) == object.");
 static PyObject *
 builtin_round(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	double x;
-	PyObject *o_ndigits = NULL;
-	Py_ssize_t ndigits;
-	static char *kwlist[] = {"number", "ndigits", 0};
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "d|O:round",
-		kwlist, &x, &o_ndigits))
-		return NULL;
-
-	if (o_ndigits == NULL) {
-		/* second argument defaults to 0 */
-		ndigits = 0;
-	}
-	else {
-		/* interpret 2nd argument as a Py_ssize_t; clip on overflow */
-		ndigits = PyNumber_AsSsize_t(o_ndigits, NULL);
-		if (ndigits == -1 && PyErr_Occurred())
-			return NULL;
-	}
-
-	/* nans, infinities and zeros round to themselves */
-	if (!Py_IS_FINITE(x) || x == 0.0)
-		return PyFloat_FromDouble(x);
-
-	/* Deal with extreme values for ndigits. For ndigits > NDIGITS_MAX, x
-	   always rounds to itself.  For ndigits < NDIGITS_MIN, x always
-	   rounds to +-0.0.  Here 0.30103 is an upper bound for log10(2). */
+    double x;
+    PyObject *o_ndigits = NULL;
+    Py_ssize_t ndigits;
+    static char *kwlist[] = {"number", "ndigits", 0};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "d|O:round",
+        kwlist, &x, &o_ndigits))
+        return NULL;
+
+    if (o_ndigits == NULL) {
+        /* second argument defaults to 0 */
+        ndigits = 0;
+    }
+    else {
+        /* interpret 2nd argument as a Py_ssize_t; clip on overflow */
+        ndigits = PyNumber_AsSsize_t(o_ndigits, NULL);
+        if (ndigits == -1 && PyErr_Occurred())
+            return NULL;
+    }
+
+    /* nans, infinities and zeros round to themselves */
+    if (!Py_IS_FINITE(x) || x == 0.0)
+        return PyFloat_FromDouble(x);
+
+    /* Deal with extreme values for ndigits. For ndigits > NDIGITS_MAX, x
+       always rounds to itself.  For ndigits < NDIGITS_MIN, x always
+       rounds to +-0.0.  Here 0.30103 is an upper bound for log10(2). */
 #define NDIGITS_MAX ((int)((DBL_MANT_DIG-DBL_MIN_EXP) * 0.30103))
 #define NDIGITS_MIN (-(int)((DBL_MAX_EXP + 1) * 0.30103))
-	if (ndigits > NDIGITS_MAX)
-		/* return x */
-		return PyFloat_FromDouble(x);
-	else if (ndigits < NDIGITS_MIN)
-		/* return 0.0, but with sign of x */
-		return PyFloat_FromDouble(0.0*x);
-	else
-		/* finite x, and ndigits is not unreasonably large */
-		/* _Py_double_round is defined in floatobject.c */
-		return _Py_double_round(x, (int)ndigits);
+    if (ndigits > NDIGITS_MAX)
+        /* return x */
+        return PyFloat_FromDouble(x);
+    else if (ndigits < NDIGITS_MIN)
+        /* return 0.0, but with sign of x */
+        return PyFloat_FromDouble(0.0*x);
+    else
+        /* finite x, and ndigits is not unreasonably large */
+        /* _Py_double_round is defined in floatobject.c */
+        return _Py_double_round(x, (int)ndigits);
 #undef NDIGITS_MAX
 #undef NDIGITS_MIN
 }
@@ -2204,42 +2204,42 @@ This always returns a floating point number.  Precision may be negative.");
 static PyObject *
 builtin_sorted(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	PyObject *newlist, *v, *seq, *compare=NULL, *keyfunc=NULL, *newargs;
-	PyObject *callable;
-	static char *kwlist[] = {"iterable", "cmp", "key", "reverse", 0};
-	int reverse;
-
-	/* args 1-4 should match listsort in Objects/listobject.c */
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOi:sorted",
-		kwlist, &seq, &compare, &keyfunc, &reverse))
-		return NULL;
-
-	newlist = PySequence_List(seq);
-	if (newlist == NULL)
-		return NULL;
-
-	callable = PyObject_GetAttrString(newlist, "sort");
-	if (callable == NULL) {
-		Py_DECREF(newlist);
-		return NULL;
-	}
-
-	newargs = PyTuple_GetSlice(args, 1, 4);
-	if (newargs == NULL) {
-		Py_DECREF(newlist);
-		Py_DECREF(callable);
-		return NULL;
-	}
-
-	v = PyObject_Call(callable, newargs, kwds);
-	Py_DECREF(newargs);
-	Py_DECREF(callable);
-	if (v == NULL) {
-		Py_DECREF(newlist);
-		return NULL;
-	}
-	Py_DECREF(v);
-	return newlist;
+    PyObject *newlist, *v, *seq, *compare=NULL, *keyfunc=NULL, *newargs;
+    PyObject *callable;
+    static char *kwlist[] = {"iterable", "cmp", "key", "reverse", 0};
+    int reverse;
+
+    /* args 1-4 should match listsort in Objects/listobject.c */
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOi:sorted",
+        kwlist, &seq, &compare, &keyfunc, &reverse))
+        return NULL;
+
+    newlist = PySequence_List(seq);
+    if (newlist == NULL)
+        return NULL;
+
+    callable = PyObject_GetAttrString(newlist, "sort");
+    if (callable == NULL) {
+        Py_DECREF(newlist);
+        return NULL;
+    }
+
+    newargs = PyTuple_GetSlice(args, 1, 4);
+    if (newargs == NULL) {
+        Py_DECREF(newlist);
+        Py_DECREF(callable);
+        return NULL;
+    }
+
+    v = PyObject_Call(callable, newargs, kwds);
+    Py_DECREF(newargs);
+    Py_DECREF(callable);
+    if (v == NULL) {
+        Py_DECREF(newlist);
+        return NULL;
+    }
+    Py_DECREF(v);
+    return newlist;
 }
 
 PyDoc_STRVAR(sorted_doc,
@@ -2248,30 +2248,30 @@ PyDoc_STRVAR(sorted_doc,
 static PyObject *
 builtin_vars(PyObject *self, PyObject *args)
 {
-	PyObject *v = NULL;
-	PyObject *d;
-
-	if (!PyArg_UnpackTuple(args, "vars", 0, 1, &v))
-		return NULL;
-	if (v == NULL) {
-		d = PyEval_GetLocals();
-		if (d == NULL) {
-			if (!PyErr_Occurred())
-				PyErr_SetString(PyExc_SystemError,
-						"vars(): no locals!?");
-		}
-		else
-			Py_INCREF(d);
-	}
-	else {
-		d = PyObject_GetAttrString(v, "__dict__");
-		if (d == NULL) {
-			PyErr_SetString(PyExc_TypeError,
-			    "vars() argument must have __dict__ attribute");
-			return NULL;
-		}
-	}
-	return d;
+    PyObject *v = NULL;
+    PyObject *d;
+
+    if (!PyArg_UnpackTuple(args, "vars", 0, 1, &v))
+        return NULL;
+    if (v == NULL) {
+        d = PyEval_GetLocals();
+        if (d == NULL) {
+            if (!PyErr_Occurred())
+                PyErr_SetString(PyExc_SystemError,
+                                "vars(): no locals!?");
+        }
+        else
+            Py_INCREF(d);
+    }
+    else {
+        d = PyObject_GetAttrString(v, "__dict__");
+        if (d == NULL) {
+            PyErr_SetString(PyExc_TypeError,
+                "vars() argument must have __dict__ attribute");
+            return NULL;
+        }
+    }
+    return d;
 }
 
 PyDoc_STRVAR(vars_doc,
@@ -2284,140 +2284,140 @@ With an argument, equivalent to object.__dict__.");
 static PyObject*
 builtin_sum(PyObject *self, PyObject *args)
 {
-	PyObject *seq;
-	PyObject *result = NULL;
-	PyObject *temp, *item, *iter;
-
-	if (!PyArg_UnpackTuple(args, "sum", 1, 2, &seq, &result))
-		return NULL;
-
-	iter = PyObject_GetIter(seq);
-	if (iter == NULL)
-		return NULL;
-
-	if (result == NULL) {
-		result = PyInt_FromLong(0);
-		if (result == NULL) {
-			Py_DECREF(iter);
-			return NULL;
-		}
-	} else {
-		/* reject string values for 'start' parameter */
-		if (PyObject_TypeCheck(result, &PyBaseString_Type)) {
-			PyErr_SetString(PyExc_TypeError,
-				"sum() can't sum strings [use ''.join(seq) instead]");
-			Py_DECREF(iter);
-			return NULL;
-		}
-		Py_INCREF(result);
-	}
+    PyObject *seq;
+    PyObject *result = NULL;
+    PyObject *temp, *item, *iter;
+
+    if (!PyArg_UnpackTuple(args, "sum", 1, 2, &seq, &result))
+        return NULL;
+
+    iter = PyObject_GetIter(seq);
+    if (iter == NULL)
+        return NULL;
+
+    if (result == NULL) {
+        result = PyInt_FromLong(0);
+        if (result == NULL) {
+            Py_DECREF(iter);
+            return NULL;
+        }
+    } else {
+        /* reject string values for 'start' parameter */
+        if (PyObject_TypeCheck(result, &PyBaseString_Type)) {
+            PyErr_SetString(PyExc_TypeError,
+                "sum() can't sum strings [use ''.join(seq) instead]");
+            Py_DECREF(iter);
+            return NULL;
+        }
+        Py_INCREF(result);
+    }
 
 #ifndef SLOW_SUM
-	/* Fast addition by keeping temporary sums in C instead of new Python objects.
-           Assumes all inputs are the same type.  If the assumption fails, default
-           to the more general routine.
-	*/
-	if (PyInt_CheckExact(result)) {
-		long i_result = PyInt_AS_LONG(result);
-		Py_DECREF(result);
-		result = NULL;
-		while(result == NULL) {
-			item = PyIter_Next(iter);
-			if (item == NULL) {
-				Py_DECREF(iter);
-				if (PyErr_Occurred())
-					return NULL;
-    				return PyInt_FromLong(i_result);
-			}
-        		if (PyInt_CheckExact(item)) {
-            			long b = PyInt_AS_LONG(item);
-				long x = i_result + b;
-				if ((x^i_result) >= 0 || (x^b) >= 0) {
-					i_result = x;
-					Py_DECREF(item);
-					continue;
-				}
-			}
-			/* Either overflowed or is not an int. Restore real objects and process normally */
-			result = PyInt_FromLong(i_result);
-			temp = PyNumber_Add(result, item);
-			Py_DECREF(result);
-			Py_DECREF(item);
-			result = temp;
-			if (result == NULL) {
-				Py_DECREF(iter);
-				return NULL;
-			}
-		}
-	}
-
-	if (PyFloat_CheckExact(result)) {
-		double f_result = PyFloat_AS_DOUBLE(result);
-		Py_DECREF(result);
-		result = NULL;
-		while(result == NULL) {
-			item = PyIter_Next(iter);
-			if (item == NULL) {
-				Py_DECREF(iter);
-				if (PyErr_Occurred())
-					return NULL;
-    				return PyFloat_FromDouble(f_result);
-			}
-        		if (PyFloat_CheckExact(item)) {
-				PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
-				f_result += PyFloat_AS_DOUBLE(item);
-				PyFPE_END_PROTECT(f_result)
-				Py_DECREF(item);
-				continue;
-			}
-        		if (PyInt_CheckExact(item)) {
-				PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
-				f_result += (double)PyInt_AS_LONG(item);
-				PyFPE_END_PROTECT(f_result)
-				Py_DECREF(item);
-				continue;
-			}
-			result = PyFloat_FromDouble(f_result);
-			temp = PyNumber_Add(result, item);
-			Py_DECREF(result);
-			Py_DECREF(item);
-			result = temp;
-			if (result == NULL) {
-				Py_DECREF(iter);
-				return NULL;
-			}
-		}
-	}
+    /* Fast addition by keeping temporary sums in C instead of new Python objects.
+       Assumes all inputs are the same type.  If the assumption fails, default
+       to the more general routine.
+    */
+    if (PyInt_CheckExact(result)) {
+        long i_result = PyInt_AS_LONG(result);
+        Py_DECREF(result);
+        result = NULL;
+        while(result == NULL) {
+            item = PyIter_Next(iter);
+            if (item == NULL) {
+                Py_DECREF(iter);
+                if (PyErr_Occurred())
+                    return NULL;
+                return PyInt_FromLong(i_result);
+            }
+            if (PyInt_CheckExact(item)) {
+                long b = PyInt_AS_LONG(item);
+                long x = i_result + b;
+                if ((x^i_result) >= 0 || (x^b) >= 0) {
+                    i_result = x;
+                    Py_DECREF(item);
+                    continue;
+                }
+            }
+            /* Either overflowed or is not an int. Restore real objects and process normally */
+            result = PyInt_FromLong(i_result);
+            temp = PyNumber_Add(result, item);
+            Py_DECREF(result);
+            Py_DECREF(item);
+            result = temp;
+            if (result == NULL) {
+                Py_DECREF(iter);
+                return NULL;
+            }
+        }
+    }
+
+    if (PyFloat_CheckExact(result)) {
+        double f_result = PyFloat_AS_DOUBLE(result);
+        Py_DECREF(result);
+        result = NULL;
+        while(result == NULL) {
+            item = PyIter_Next(iter);
+            if (item == NULL) {
+                Py_DECREF(iter);
+                if (PyErr_Occurred())
+                    return NULL;
+                return PyFloat_FromDouble(f_result);
+            }
+            if (PyFloat_CheckExact(item)) {
+                PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
+                f_result += PyFloat_AS_DOUBLE(item);
+                PyFPE_END_PROTECT(f_result)
+                Py_DECREF(item);
+                continue;
+            }
+            if (PyInt_CheckExact(item)) {
+                PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
+                f_result += (double)PyInt_AS_LONG(item);
+                PyFPE_END_PROTECT(f_result)
+                Py_DECREF(item);
+                continue;
+            }
+            result = PyFloat_FromDouble(f_result);
+            temp = PyNumber_Add(result, item);
+            Py_DECREF(result);
+            Py_DECREF(item);
+            result = temp;
+            if (result == NULL) {
+                Py_DECREF(iter);
+                return NULL;
+            }
+        }
+    }
 #endif
 
-	for(;;) {
-		item = PyIter_Next(iter);
-		if (item == NULL) {
-			/* error, or end-of-sequence */
-			if (PyErr_Occurred()) {
-				Py_DECREF(result);
-				result = NULL;
-			}
-			break;
-		}
-		/* It's tempting to use PyNumber_InPlaceAdd instead of
-		   PyNumber_Add here, to avoid quadratic running time
-		   when doing 'sum(list_of_lists, [])'.  However, this
-		   would produce a change in behaviour: a snippet like
-
-		     empty = []
-		     sum([[x] for x in range(10)], empty)
-
-		   would change the value of empty. */
-		temp = PyNumber_Add(result, item);
-		Py_DECREF(result);
-		Py_DECREF(item);
-		result = temp;
-		if (result == NULL)
-			break;
-	}
-	Py_DECREF(iter);
-	return result;
+    for(;;) {
+        item = PyIter_Next(iter);
+        if (item == NULL) {
+            /* error, or end-of-sequence */
+            if (PyErr_Occurred()) {
+                Py_DECREF(result);
+                result = NULL;
+            }
+            break;
+        }
+        /* It's tempting to use PyNumber_InPlaceAdd instead of
+           PyNumber_Add here, to avoid quadratic running time
+           when doing 'sum(list_of_lists, [])'.  However, this
+           would produce a change in behaviour: a snippet like
+
+             empty = []
+             sum([[x] for x in range(10)], empty)
+
+           would change the value of empty. */
+        temp = PyNumber_Add(result, item);
+        Py_DECREF(result);
+        Py_DECREF(item);
+        result = temp;
+        if (result == NULL)
+            break;
+    }
+    Py_DECREF(iter);
+    return result;
 }
 
 PyDoc_STRVAR(sum_doc,
@@ -2431,17 +2431,17 @@ empty, returns start.");
 static PyObject *
 builtin_isinstance(PyObject *self, PyObject *args)
 {
-	PyObject *inst;
-	PyObject *cls;
-	int retval;
+    PyObject *inst;
+    PyObject *cls;
+    int retval;
 
-	if (!PyArg_UnpackTuple(args, "isinstance", 2, 2, &inst, &cls))
-		return NULL;
+    if (!PyArg_UnpackTuple(args, "isinstance", 2, 2, &inst, &cls))
+        return NULL;
 
-	retval = PyObject_IsInstance(inst, cls);
-	if (retval < 0)
-		return NULL;
-	return PyBool_FromLong(retval);
+    retval = PyObject_IsInstance(inst, cls);
+    if (retval < 0)
+        return NULL;
+    return PyBool_FromLong(retval);
 }
 
 PyDoc_STRVAR(isinstance_doc,
@@ -2456,17 +2456,17 @@ isinstance(x, A) or isinstance(x, B) or ... (etc.).");
 static PyObject *
 builtin_issubclass(PyObject *self, PyObject *args)
 {
-	PyObject *derived;
-	PyObject *cls;
-	int retval;
+    PyObject *derived;
+    PyObject *cls;
+    int retval;
 
-	if (!PyArg_UnpackTuple(args, "issubclass", 2, 2, &derived, &cls))
-		return NULL;
+    if (!PyArg_UnpackTuple(args, "issubclass", 2, 2, &derived, &cls))
+        return NULL;
 
-	retval = PyObject_IsSubclass(derived, cls);
-	if (retval < 0)
-		return NULL;
-	return PyBool_FromLong(retval);
+    retval = PyObject_IsSubclass(derived, cls);
+    if (retval < 0)
+        return NULL;
+    return PyBool_FromLong(retval);
 }
 
 PyDoc_STRVAR(issubclass_doc,
@@ -2480,104 +2480,104 @@ is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).");
 static PyObject*
 builtin_zip(PyObject *self, PyObject *args)
 {
-	PyObject *ret;
-	const Py_ssize_t itemsize = PySequence_Length(args);
-	Py_ssize_t i;
-	PyObject *itlist;  /* tuple of iterators */
-	Py_ssize_t len;	   /* guess at result length */
-
-	if (itemsize == 0)
-		return PyList_New(0);
-
-	/* args must be a tuple */
-	assert(PyTuple_Check(args));
-
-	/* Guess at result length:  the shortest of the input lengths.
-	   If some argument refuses to say, we refuse to guess too, lest
-	   an argument like xrange(sys.maxint) lead us astray.*/
-	len = -1;	/* unknown */
-	for (i = 0; i < itemsize; ++i) {
-		PyObject *item = PyTuple_GET_ITEM(args, i);
-		Py_ssize_t thislen = _PyObject_LengthHint(item, -2);
-		if (thislen < 0) {
-			if (thislen == -1)
-				return NULL;
-			len = -1;
-			break;
-		}
-		else if (len < 0 || thislen < len)
-			len = thislen;
-	}
-
-	/* allocate result list */
-	if (len < 0)
-		len = 10;	/* arbitrary */
-	if ((ret = PyList_New(len)) == NULL)
-		return NULL;
-
-	/* obtain iterators */
-	itlist = PyTuple_New(itemsize);
-	if (itlist == NULL)
-		goto Fail_ret;
-	for (i = 0; i < itemsize; ++i) {
-		PyObject *item = PyTuple_GET_ITEM(args, i);
-		PyObject *it = PyObject_GetIter(item);
-		if (it == NULL) {
-			if (PyErr_ExceptionMatches(PyExc_TypeError))
-				PyErr_Format(PyExc_TypeError,
-				    "zip argument #%zd must support iteration",
-				    i+1);
-			goto Fail_ret_itlist;
-		}
-		PyTuple_SET_ITEM(itlist, i, it);
-	}
-
-	/* build result into ret list */
-	for (i = 0; ; ++i) {
-		int j;
-		PyObject *next = PyTuple_New(itemsize);
-		if (!next)
-			goto Fail_ret_itlist;
-
-		for (j = 0; j < itemsize; j++) {
-			PyObject *it = PyTuple_GET_ITEM(itlist, j);
-			PyObject *item = PyIter_Next(it);
-			if (!item) {
-				if (PyErr_Occurred()) {
-					Py_DECREF(ret);
-					ret = NULL;
-				}
-				Py_DECREF(next);
-				Py_DECREF(itlist);
-				goto Done;
-			}
-			PyTuple_SET_ITEM(next, j, item);
-		}
-
-		if (i < len)
-			PyList_SET_ITEM(ret, i, next);
-		else {
-			int status = PyList_Append(ret, next);
-			Py_DECREF(next);
-			++len;
-			if (status < 0)
-				goto Fail_ret_itlist;
-		}
-	}
+    PyObject *ret;
+    const Py_ssize_t itemsize = PySequence_Length(args);
+    Py_ssize_t i;
+    PyObject *itlist;  /* tuple of iterators */
+    Py_ssize_t len;        /* guess at result length */
+
+    if (itemsize == 0)
+        return PyList_New(0);
+
+    /* args must be a tuple */
+    assert(PyTuple_Check(args));
+
+    /* Guess at result length:  the shortest of the input lengths.
+       If some argument refuses to say, we refuse to guess too, lest
+       an argument like xrange(sys.maxint) lead us astray.*/
+    len = -1;           /* unknown */
+    for (i = 0; i < itemsize; ++i) {
+        PyObject *item = PyTuple_GET_ITEM(args, i);
+        Py_ssize_t thislen = _PyObject_LengthHint(item, -2);
+        if (thislen < 0) {
+            if (thislen == -1)
+                return NULL;
+            len = -1;
+            break;
+        }
+        else if (len < 0 || thislen < len)
+            len = thislen;
+    }
+
+    /* allocate result list */
+    if (len < 0)
+        len = 10;               /* arbitrary */
+    if ((ret = PyList_New(len)) == NULL)
+        return NULL;
+
+    /* obtain iterators */
+    itlist = PyTuple_New(itemsize);
+    if (itlist == NULL)
+        goto Fail_ret;
+    for (i = 0; i < itemsize; ++i) {
+        PyObject *item = PyTuple_GET_ITEM(args, i);
+        PyObject *it = PyObject_GetIter(item);
+        if (it == NULL) {
+            if (PyErr_ExceptionMatches(PyExc_TypeError))
+                PyErr_Format(PyExc_TypeError,
+                    "zip argument #%zd must support iteration",
+                    i+1);
+            goto Fail_ret_itlist;
+        }
+        PyTuple_SET_ITEM(itlist, i, it);
+    }
+
+    /* build result into ret list */
+    for (i = 0; ; ++i) {
+        int j;
+        PyObject *next = PyTuple_New(itemsize);
+        if (!next)
+            goto Fail_ret_itlist;
+
+        for (j = 0; j < itemsize; j++) {
+            PyObject *it = PyTuple_GET_ITEM(itlist, j);
+            PyObject *item = PyIter_Next(it);
+            if (!item) {
+                if (PyErr_Occurred()) {
+                    Py_DECREF(ret);
+                    ret = NULL;
+                }
+                Py_DECREF(next);
+                Py_DECREF(itlist);
+                goto Done;
+            }
+            PyTuple_SET_ITEM(next, j, item);
+        }
+
+        if (i < len)
+            PyList_SET_ITEM(ret, i, next);
+        else {
+            int status = PyList_Append(ret, next);
+            Py_DECREF(next);
+            ++len;
+            if (status < 0)
+                goto Fail_ret_itlist;
+        }
+    }
 
 Done:
-	if (ret != NULL && i < len) {
-		/* The list is too big. */
-		if (PyList_SetSlice(ret, i, len, NULL) < 0)
-			return NULL;
-	}
-	return ret;
+    if (ret != NULL && i < len) {
+        /* The list is too big. */
+        if (PyList_SetSlice(ret, i, len, NULL) < 0)
+            return NULL;
+    }
+    return ret;
 
 Fail_ret_itlist:
-	Py_DECREF(itlist);
+    Py_DECREF(itlist);
 Fail_ret:
-	Py_DECREF(ret);
-	return NULL;
+    Py_DECREF(ret);
+    return NULL;
 }
 
 
@@ -2590,61 +2590,61 @@ in length to the length of the shortest argument sequence.");
 
 
 static PyMethodDef builtin_methods[] = {
- 	{"__import__",	(PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc},
- 	{"abs",		builtin_abs,        METH_O, abs_doc},
- 	{"all",		builtin_all,        METH_O, all_doc},
- 	{"any",		builtin_any,        METH_O, any_doc},
- 	{"apply",	builtin_apply,      METH_VARARGS, apply_doc},
-	{"bin",		builtin_bin,	    METH_O, bin_doc},
- 	{"callable",	builtin_callable,   METH_O, callable_doc},
- 	{"chr",		builtin_chr,        METH_VARARGS, chr_doc},
- 	{"cmp",		builtin_cmp,        METH_VARARGS, cmp_doc},
- 	{"coerce",	builtin_coerce,     METH_VARARGS, coerce_doc},
- 	{"compile",	(PyCFunction)builtin_compile,    METH_VARARGS | METH_KEYWORDS, compile_doc},
- 	{"delattr",	builtin_delattr,    METH_VARARGS, delattr_doc},
- 	{"dir",		builtin_dir,        METH_VARARGS, dir_doc},
- 	{"divmod",	builtin_divmod,     METH_VARARGS, divmod_doc},
- 	{"eval",	builtin_eval,       METH_VARARGS, eval_doc},
- 	{"execfile",	builtin_execfile,   METH_VARARGS, execfile_doc},
- 	{"filter",	builtin_filter,     METH_VARARGS, filter_doc},
- 	{"format",	builtin_format,     METH_VARARGS, format_doc},
- 	{"getattr",	builtin_getattr,    METH_VARARGS, getattr_doc},
- 	{"globals",	(PyCFunction)builtin_globals,    METH_NOARGS, globals_doc},
- 	{"hasattr",	builtin_hasattr,    METH_VARARGS, hasattr_doc},
- 	{"hash",	builtin_hash,       METH_O, hash_doc},
- 	{"hex",		builtin_hex,        METH_O, hex_doc},
- 	{"id",		builtin_id,         METH_O, id_doc},
- 	{"input",	builtin_input,      METH_VARARGS, input_doc},
- 	{"intern",	builtin_intern,     METH_VARARGS, intern_doc},
- 	{"isinstance",  builtin_isinstance, METH_VARARGS, isinstance_doc},
- 	{"issubclass",  builtin_issubclass, METH_VARARGS, issubclass_doc},
- 	{"iter",	builtin_iter,       METH_VARARGS, iter_doc},
- 	{"len",		builtin_len,        METH_O, len_doc},
- 	{"locals",	(PyCFunction)builtin_locals,     METH_NOARGS, locals_doc},
- 	{"map",		builtin_map,        METH_VARARGS, map_doc},
- 	{"max",		(PyCFunction)builtin_max,        METH_VARARGS | METH_KEYWORDS, max_doc},
- 	{"min",		(PyCFunction)builtin_min,        METH_VARARGS | METH_KEYWORDS, min_doc},
-	{"next", 	builtin_next,       METH_VARARGS, next_doc},
- 	{"oct",		builtin_oct,        METH_O, oct_doc},
- 	{"open",	(PyCFunction)builtin_open,       METH_VARARGS | METH_KEYWORDS, open_doc},
- 	{"ord",		builtin_ord,        METH_O, ord_doc},
- 	{"pow",		builtin_pow,        METH_VARARGS, pow_doc},
- 	{"print",	(PyCFunction)builtin_print,      METH_VARARGS | METH_KEYWORDS, print_doc},
- 	{"range",	builtin_range,      METH_VARARGS, range_doc},
- 	{"raw_input",	builtin_raw_input,  METH_VARARGS, raw_input_doc},
- 	{"reduce",	builtin_reduce,     METH_VARARGS, reduce_doc},
- 	{"reload",	builtin_reload,     METH_O, reload_doc},
- 	{"repr",	builtin_repr,       METH_O, repr_doc},
- 	{"round",	(PyCFunction)builtin_round,      METH_VARARGS | METH_KEYWORDS, round_doc},
- 	{"setattr",	builtin_setattr,    METH_VARARGS, setattr_doc},
- 	{"sorted",	(PyCFunction)builtin_sorted,     METH_VARARGS | METH_KEYWORDS, sorted_doc},
- 	{"sum",		builtin_sum,        METH_VARARGS, sum_doc},
+    {"__import__",      (PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc},
+    {"abs",             builtin_abs,        METH_O, abs_doc},
+    {"all",             builtin_all,        METH_O, all_doc},
+    {"any",             builtin_any,        METH_O, any_doc},
+    {"apply",           builtin_apply,      METH_VARARGS, apply_doc},
+    {"bin",             builtin_bin,        METH_O, bin_doc},
+    {"callable",        builtin_callable,   METH_O, callable_doc},
+    {"chr",             builtin_chr,        METH_VARARGS, chr_doc},
+    {"cmp",             builtin_cmp,        METH_VARARGS, cmp_doc},
+    {"coerce",          builtin_coerce,     METH_VARARGS, coerce_doc},
+    {"compile",         (PyCFunction)builtin_compile,    METH_VARARGS | METH_KEYWORDS, compile_doc},
+    {"delattr",         builtin_delattr,    METH_VARARGS, delattr_doc},
+    {"dir",             builtin_dir,        METH_VARARGS, dir_doc},
+    {"divmod",          builtin_divmod,     METH_VARARGS, divmod_doc},
+    {"eval",            builtin_eval,       METH_VARARGS, eval_doc},
+    {"execfile",        builtin_execfile,   METH_VARARGS, execfile_doc},
+    {"filter",          builtin_filter,     METH_VARARGS, filter_doc},
+    {"format",          builtin_format,     METH_VARARGS, format_doc},
+    {"getattr",         builtin_getattr,    METH_VARARGS, getattr_doc},
+    {"globals",         (PyCFunction)builtin_globals,    METH_NOARGS, globals_doc},
+    {"hasattr",         builtin_hasattr,    METH_VARARGS, hasattr_doc},
+    {"hash",            builtin_hash,       METH_O, hash_doc},
+    {"hex",             builtin_hex,        METH_O, hex_doc},
+    {"id",              builtin_id,         METH_O, id_doc},
+    {"input",           builtin_input,      METH_VARARGS, input_doc},
+    {"intern",          builtin_intern,     METH_VARARGS, intern_doc},
+    {"isinstance",  builtin_isinstance, METH_VARARGS, isinstance_doc},
+    {"issubclass",  builtin_issubclass, METH_VARARGS, issubclass_doc},
+    {"iter",            builtin_iter,       METH_VARARGS, iter_doc},
+    {"len",             builtin_len,        METH_O, len_doc},
+    {"locals",          (PyCFunction)builtin_locals,     METH_NOARGS, locals_doc},
+    {"map",             builtin_map,        METH_VARARGS, map_doc},
+    {"max",             (PyCFunction)builtin_max,        METH_VARARGS | METH_KEYWORDS, max_doc},
+    {"min",             (PyCFunction)builtin_min,        METH_VARARGS | METH_KEYWORDS, min_doc},
+    {"next",            builtin_next,       METH_VARARGS, next_doc},
+    {"oct",             builtin_oct,        METH_O, oct_doc},
+    {"open",            (PyCFunction)builtin_open,       METH_VARARGS | METH_KEYWORDS, open_doc},
+    {"ord",             builtin_ord,        METH_O, ord_doc},
+    {"pow",             builtin_pow,        METH_VARARGS, pow_doc},
+    {"print",           (PyCFunction)builtin_print,      METH_VARARGS | METH_KEYWORDS, print_doc},
+    {"range",           builtin_range,      METH_VARARGS, range_doc},
+    {"raw_input",       builtin_raw_input,  METH_VARARGS, raw_input_doc},
+    {"reduce",          builtin_reduce,     METH_VARARGS, reduce_doc},
+    {"reload",          builtin_reload,     METH_O, reload_doc},
+    {"repr",            builtin_repr,       METH_O, repr_doc},
+    {"round",           (PyCFunction)builtin_round,      METH_VARARGS | METH_KEYWORDS, round_doc},
+    {"setattr",         builtin_setattr,    METH_VARARGS, setattr_doc},
+    {"sorted",          (PyCFunction)builtin_sorted,     METH_VARARGS | METH_KEYWORDS, sorted_doc},
+    {"sum",             builtin_sum,        METH_VARARGS, sum_doc},
 #ifdef Py_USING_UNICODE
- 	{"unichr",	builtin_unichr,     METH_VARARGS, unichr_doc},
+    {"unichr",          builtin_unichr,     METH_VARARGS, unichr_doc},
 #endif
- 	{"vars",	builtin_vars,       METH_VARARGS, vars_doc},
-  	{"zip",         builtin_zip,        METH_VARARGS, zip_doc},
-	{NULL,		NULL},
+    {"vars",            builtin_vars,       METH_VARARGS, vars_doc},
+    {"zip",         builtin_zip,        METH_VARARGS, zip_doc},
+    {NULL,              NULL},
 };
 
 PyDoc_STRVAR(builtin_doc,
@@ -2655,76 +2655,76 @@ Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.");
 PyObject *
 _PyBuiltin_Init(void)
 {
-	PyObject *mod, *dict, *debug;
-	mod = Py_InitModule4("__builtin__", builtin_methods,
-			     builtin_doc, (PyObject *)NULL,
-			     PYTHON_API_VERSION);
-	if (mod == NULL)
-		return NULL;
-	dict = PyModule_GetDict(mod);
+    PyObject *mod, *dict, *debug;
+    mod = Py_InitModule4("__builtin__", builtin_methods,
+                         builtin_doc, (PyObject *)NULL,
+                         PYTHON_API_VERSION);
+    if (mod == NULL)
+        return NULL;
+    dict = PyModule_GetDict(mod);
 
 #ifdef Py_TRACE_REFS
-	/* __builtin__ exposes a number of statically allocated objects
-	 * that, before this code was added in 2.3, never showed up in
-	 * the list of "all objects" maintained by Py_TRACE_REFS.  As a
-	 * result, programs leaking references to None and False (etc)
-	 * couldn't be diagnosed by examining sys.getobjects(0).
-	 */
+    /* __builtin__ exposes a number of statically allocated objects
+     * that, before this code was added in 2.3, never showed up in
+     * the list of "all objects" maintained by Py_TRACE_REFS.  As a
+     * result, programs leaking references to None and False (etc)
+     * couldn't be diagnosed by examining sys.getobjects(0).
+     */
 #define ADD_TO_ALL(OBJECT) _Py_AddToAllObjects((PyObject *)(OBJECT), 0)
 #else
 #define ADD_TO_ALL(OBJECT) (void)0
 #endif
 
 #define SETBUILTIN(NAME, OBJECT) \
-	if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0)	\
-		return NULL;						\
-	ADD_TO_ALL(OBJECT)
-
-	SETBUILTIN("None",		Py_None);
-	SETBUILTIN("Ellipsis",		Py_Ellipsis);
-	SETBUILTIN("NotImplemented",	Py_NotImplemented);
-	SETBUILTIN("False",		Py_False);
-	SETBUILTIN("True",		Py_True);
-	SETBUILTIN("basestring",	&PyBaseString_Type);
-	SETBUILTIN("bool",		&PyBool_Type);
-	SETBUILTIN("memoryview",        &PyMemoryView_Type);
-	SETBUILTIN("bytearray",		&PyByteArray_Type);
-	SETBUILTIN("bytes",		&PyString_Type);
-	SETBUILTIN("buffer",		&PyBuffer_Type);
-	SETBUILTIN("classmethod",	&PyClassMethod_Type);
+    if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0)       \
+        return NULL;                                                    \
+    ADD_TO_ALL(OBJECT)
+
+    SETBUILTIN("None",                  Py_None);
+    SETBUILTIN("Ellipsis",              Py_Ellipsis);
+    SETBUILTIN("NotImplemented",        Py_NotImplemented);
+    SETBUILTIN("False",                 Py_False);
+    SETBUILTIN("True",                  Py_True);
+    SETBUILTIN("basestring",            &PyBaseString_Type);
+    SETBUILTIN("bool",                  &PyBool_Type);
+    SETBUILTIN("memoryview",        &PyMemoryView_Type);
+    SETBUILTIN("bytearray",             &PyByteArray_Type);
+    SETBUILTIN("bytes",                 &PyString_Type);
+    SETBUILTIN("buffer",                &PyBuffer_Type);
+    SETBUILTIN("classmethod",           &PyClassMethod_Type);
 #ifndef WITHOUT_COMPLEX
-	SETBUILTIN("complex",		&PyComplex_Type);
+    SETBUILTIN("complex",               &PyComplex_Type);
 #endif
-	SETBUILTIN("dict",		&PyDict_Type);
- 	SETBUILTIN("enumerate",		&PyEnum_Type);
-	SETBUILTIN("file",		&PyFile_Type);
-	SETBUILTIN("float",		&PyFloat_Type);
-	SETBUILTIN("frozenset",		&PyFrozenSet_Type);
-	SETBUILTIN("property",		&PyProperty_Type);
-	SETBUILTIN("int",		&PyInt_Type);
-	SETBUILTIN("list",		&PyList_Type);
-	SETBUILTIN("long",		&PyLong_Type);
-	SETBUILTIN("object",		&PyBaseObject_Type);
-	SETBUILTIN("reversed",		&PyReversed_Type);
-	SETBUILTIN("set",		&PySet_Type);
-	SETBUILTIN("slice",		&PySlice_Type);
-	SETBUILTIN("staticmethod",	&PyStaticMethod_Type);
-	SETBUILTIN("str",		&PyString_Type);
-	SETBUILTIN("super",		&PySuper_Type);
-	SETBUILTIN("tuple",		&PyTuple_Type);
-	SETBUILTIN("type",		&PyType_Type);
-	SETBUILTIN("xrange",		&PyRange_Type);
+    SETBUILTIN("dict",                  &PyDict_Type);
+    SETBUILTIN("enumerate",             &PyEnum_Type);
+    SETBUILTIN("file",                  &PyFile_Type);
+    SETBUILTIN("float",                 &PyFloat_Type);
+    SETBUILTIN("frozenset",             &PyFrozenSet_Type);
+    SETBUILTIN("property",              &PyProperty_Type);
+    SETBUILTIN("int",                   &PyInt_Type);
+    SETBUILTIN("list",                  &PyList_Type);
+    SETBUILTIN("long",                  &PyLong_Type);
+    SETBUILTIN("object",                &PyBaseObject_Type);
+    SETBUILTIN("reversed",              &PyReversed_Type);
+    SETBUILTIN("set",                   &PySet_Type);
+    SETBUILTIN("slice",                 &PySlice_Type);
+    SETBUILTIN("staticmethod",          &PyStaticMethod_Type);
+    SETBUILTIN("str",                   &PyString_Type);
+    SETBUILTIN("super",                 &PySuper_Type);
+    SETBUILTIN("tuple",                 &PyTuple_Type);
+    SETBUILTIN("type",                  &PyType_Type);
+    SETBUILTIN("xrange",                &PyRange_Type);
 #ifdef Py_USING_UNICODE
-	SETBUILTIN("unicode",		&PyUnicode_Type);
+    SETBUILTIN("unicode",               &PyUnicode_Type);
 #endif
-	debug = PyBool_FromLong(Py_OptimizeFlag == 0);
-	if (PyDict_SetItemString(dict, "__debug__", debug) < 0) {
-		Py_XDECREF(debug);
-		return NULL;
-	}
-	Py_XDECREF(debug);
-
-	return mod;
+    debug = PyBool_FromLong(Py_OptimizeFlag == 0);
+    if (PyDict_SetItemString(dict, "__debug__", debug) < 0) {
+        Py_XDECREF(debug);
+        return NULL;
+    }
+    Py_XDECREF(debug);
+
+    return mod;
 #undef ADD_TO_ALL
 #undef SETBUILTIN
 }
@@ -2734,69 +2734,69 @@ _PyBuiltin_Init(void)
 static PyObject *
 filtertuple(PyObject *func, PyObject *tuple)
 {
-	PyObject *result;
-	Py_ssize_t i, j;
-	Py_ssize_t len = PyTuple_Size(tuple);
-
-	if (len == 0) {
-		if (PyTuple_CheckExact(tuple))
-			Py_INCREF(tuple);
-		else
-			tuple = PyTuple_New(0);
-		return tuple;
-	}
-
-	if ((result = PyTuple_New(len)) == NULL)
-		return NULL;
-
-	for (i = j = 0; i < len; ++i) {
-		PyObject *item, *good;
-		int ok;
-
-		if (tuple->ob_type->tp_as_sequence &&
-		    tuple->ob_type->tp_as_sequence->sq_item) {
-			item = tuple->ob_type->tp_as_sequence->sq_item(tuple, i);
-			if (item == NULL)
-				goto Fail_1;
-		} else {
-			PyErr_SetString(PyExc_TypeError, "filter(): unsubscriptable tuple");
-			goto Fail_1;
-		}
-		if (func == Py_None) {
-			Py_INCREF(item);
-			good = item;
-		}
-		else {
-			PyObject *arg = PyTuple_Pack(1, item);
-			if (arg == NULL) {
-				Py_DECREF(item);
-				goto Fail_1;
-			}
-			good = PyEval_CallObject(func, arg);
-			Py_DECREF(arg);
-			if (good == NULL) {
-				Py_DECREF(item);
-				goto Fail_1;
-			}
-		}
-		ok = PyObject_IsTrue(good);
-		Py_DECREF(good);
-		if (ok) {
-			if (PyTuple_SetItem(result, j++, item) < 0)
-				goto Fail_1;
-		}
-		else
-			Py_DECREF(item);
-	}
-
-	if (_PyTuple_Resize(&result, j) < 0)
-		return NULL;
-
-	return result;
+    PyObject *result;
+    Py_ssize_t i, j;
+    Py_ssize_t len = PyTuple_Size(tuple);
+
+    if (len == 0) {
+        if (PyTuple_CheckExact(tuple))
+            Py_INCREF(tuple);
+        else
+            tuple = PyTuple_New(0);
+        return tuple;
+    }
+
+    if ((result = PyTuple_New(len)) == NULL)
+        return NULL;
+
+    for (i = j = 0; i < len; ++i) {
+        PyObject *item, *good;
+        int ok;
+
+        if (tuple->ob_type->tp_as_sequence &&
+            tuple->ob_type->tp_as_sequence->sq_item) {
+            item = tuple->ob_type->tp_as_sequence->sq_item(tuple, i);
+            if (item == NULL)
+                goto Fail_1;
+        } else {
+            PyErr_SetString(PyExc_TypeError, "filter(): unsubscriptable tuple");
+            goto Fail_1;
+        }
+        if (func == Py_None) {
+            Py_INCREF(item);
+            good = item;
+        }
+        else {
+            PyObject *arg = PyTuple_Pack(1, item);
+            if (arg == NULL) {
+                Py_DECREF(item);
+                goto Fail_1;
+            }
+            good = PyEval_CallObject(func, arg);
+            Py_DECREF(arg);
+            if (good == NULL) {
+                Py_DECREF(item);
+                goto Fail_1;
+            }
+        }
+        ok = PyObject_IsTrue(good);
+        Py_DECREF(good);
+        if (ok) {
+            if (PyTuple_SetItem(result, j++, item) < 0)
+                goto Fail_1;
+        }
+        else
+            Py_DECREF(item);
+    }
+
+    if (_PyTuple_Resize(&result, j) < 0)
+        return NULL;
+
+    return result;
 
 Fail_1:
-	Py_DECREF(result);
-	return NULL;
+    Py_DECREF(result);
+    return NULL;
 }
 
 
@@ -2805,125 +2805,125 @@ Fail_1:
 static PyObject *
 filterstring(PyObject *func, PyObject *strobj)
 {
-	PyObject *result;
-	Py_ssize_t i, j;
-	Py_ssize_t len = PyString_Size(strobj);
-	Py_ssize_t outlen = len;
-
-	if (func == Py_None) {
-		/* If it's a real string we can return the original,
-		 * as no character is ever false and __getitem__
-		 * does return this character. If it's a subclass
-		 * we must go through the __getitem__ loop */
-		if (PyString_CheckExact(strobj)) {
-			Py_INCREF(strobj);
-			return strobj;
-		}
-	}
-	if ((result = PyString_FromStringAndSize(NULL, len)) == NULL)
-		return NULL;
-
-	for (i = j = 0; i < len; ++i) {
-		PyObject *item;
-		int ok;
-
-		item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
-		if (item == NULL)
-			goto Fail_1;
-		if (func==Py_None) {
-			ok = 1;
-		} else {
-			PyObject *arg, *good;
-			arg = PyTuple_Pack(1, item);
-			if (arg == NULL) {
-				Py_DECREF(item);
-				goto Fail_1;
-			}
-			good = PyEval_CallObject(func, arg);
-			Py_DECREF(arg);
-			if (good == NULL) {
-				Py_DECREF(item);
-				goto Fail_1;
-			}
-			ok = PyObject_IsTrue(good);
-			Py_DECREF(good);
-		}
-		if (ok) {
-			Py_ssize_t reslen;
-			if (!PyString_Check(item)) {
-				PyErr_SetString(PyExc_TypeError, "can't filter str to str:"
-					" __getitem__ returned different type");
-				Py_DECREF(item);
-				goto Fail_1;
-			}
-			reslen = PyString_GET_SIZE(item);
-			if (reslen == 1) {
-				PyString_AS_STRING(result)[j++] =
-					PyString_AS_STRING(item)[0];
-			} else {
-				/* do we need more space? */
-				Py_ssize_t need = j;
-
-				/* calculate space requirements while checking for overflow */
-				if (need > PY_SSIZE_T_MAX - reslen) {
-					Py_DECREF(item);
-					goto Fail_1;
-				}
-
-				need += reslen;
-
-				if (need > PY_SSIZE_T_MAX - len) {
-					Py_DECREF(item);
-					goto Fail_1;
-				}
-
-				need += len;
-
-				if (need <= i) {
-					Py_DECREF(item);
-					goto Fail_1;
-				}
-
-				need = need - i - 1;
-
-				assert(need >= 0);
-				assert(outlen >= 0);
-
-				if (need > outlen) {
-					/* overallocate, to avoid reallocations */
-					if (outlen > PY_SSIZE_T_MAX / 2) {
-						Py_DECREF(item);
-						return NULL;
-					}
-
-					if (need<2*outlen) {
-						need = 2*outlen;
-          }
-					if (_PyString_Resize(&result, need)) {
-						Py_DECREF(item);
-						return NULL;
-					}
-					outlen = need;
-				}
-				memcpy(
-					PyString_AS_STRING(result) + j,
-					PyString_AS_STRING(item),
-					reslen
-				);
-				j += reslen;
-			}
-		}
-		Py_DECREF(item);
-	}
-
-	if (j < outlen)
-		_PyString_Resize(&result, j);
-
-	return result;
+    PyObject *result;
+    Py_ssize_t i, j;
+    Py_ssize_t len = PyString_Size(strobj);
+    Py_ssize_t outlen = len;
+
+    if (func == Py_None) {
+        /* If it's a real string we can return the original,
+         * as no character is ever false and __getitem__
+         * does return this character. If it's a subclass
+         * we must go through the __getitem__ loop */
+        if (PyString_CheckExact(strobj)) {
+            Py_INCREF(strobj);
+            return strobj;
+        }
+    }
+    if ((result = PyString_FromStringAndSize(NULL, len)) == NULL)
+        return NULL;
+
+    for (i = j = 0; i < len; ++i) {
+        PyObject *item;
+        int ok;
+
+        item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
+        if (item == NULL)
+            goto Fail_1;
+        if (func==Py_None) {
+            ok = 1;
+        } else {
+            PyObject *arg, *good;
+            arg = PyTuple_Pack(1, item);
+            if (arg == NULL) {
+                Py_DECREF(item);
+                goto Fail_1;
+            }
+            good = PyEval_CallObject(func, arg);
+            Py_DECREF(arg);
+            if (good == NULL) {
+                Py_DECREF(item);
+                goto Fail_1;
+            }
+            ok = PyObject_IsTrue(good);
+            Py_DECREF(good);
+        }
+        if (ok) {
+            Py_ssize_t reslen;
+            if (!PyString_Check(item)) {
+                PyErr_SetString(PyExc_TypeError, "can't filter str to str:"
+                    " __getitem__ returned different type");
+                Py_DECREF(item);
+                goto Fail_1;
+            }
+            reslen = PyString_GET_SIZE(item);
+            if (reslen == 1) {
+                PyString_AS_STRING(result)[j++] =
+                    PyString_AS_STRING(item)[0];
+            } else {
+                /* do we need more space? */
+                Py_ssize_t need = j;
+
+                /* calculate space requirements while checking for overflow */
+                if (need > PY_SSIZE_T_MAX - reslen) {
+                    Py_DECREF(item);
+                    goto Fail_1;
+                }
+
+                need += reslen;
+
+                if (need > PY_SSIZE_T_MAX - len) {
+                    Py_DECREF(item);
+                    goto Fail_1;
+                }
+
+                need += len;
+
+                if (need <= i) {
+                    Py_DECREF(item);
+                    goto Fail_1;
+                }
+
+                need = need - i - 1;
+
+                assert(need >= 0);
+                assert(outlen >= 0);
+
+                if (need > outlen) {
+                    /* overallocate, to avoid reallocations */
+                    if (outlen > PY_SSIZE_T_MAX / 2) {
+                        Py_DECREF(item);
+                        return NULL;
+                    }
+
+                    if (need<2*outlen) {
+                        need = 2*outlen;
+      }
+                                    if (_PyString_Resize(&result, need)) {
+                                            Py_DECREF(item);
+                                            return NULL;
+                                    }
+                                    outlen = need;
+                            }
+                            memcpy(
+                                    PyString_AS_STRING(result) + j,
+                                    PyString_AS_STRING(item),
+                                    reslen
+                            );
+                            j += reslen;
+                    }
+        }
+        Py_DECREF(item);
+    }
+
+    if (j < outlen)
+        _PyString_Resize(&result, j);
+
+    return result;
 
 Fail_1:
-	Py_DECREF(result);
-	return NULL;
+    Py_DECREF(result);
+    return NULL;
 }
 
 #ifdef Py_USING_UNICODE
@@ -2932,112 +2932,112 @@ Fail_1:
 static PyObject *
 filterunicode(PyObject *func, PyObject *strobj)
 {
-	PyObject *result;
-	register Py_ssize_t i, j;
-	Py_ssize_t len = PyUnicode_GetSize(strobj);
-	Py_ssize_t outlen = len;
-
-	if (func == Py_None) {
-		/* If it's a real string we can return the original,
-		 * as no character is ever false and __getitem__
-		 * does return this character. If it's a subclass
-		 * we must go through the __getitem__ loop */
-		if (PyUnicode_CheckExact(strobj)) {
-			Py_INCREF(strobj);
-			return strobj;
-		}
-	}
-	if ((result = PyUnicode_FromUnicode(NULL, len)) == NULL)
-		return NULL;
-
-	for (i = j = 0; i < len; ++i) {
-		PyObject *item, *arg, *good;
-		int ok;
-
-		item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
-		if (item == NULL)
-			goto Fail_1;
-		if (func == Py_None) {
-			ok = 1;
-		} else {
-			arg = PyTuple_Pack(1, item);
-			if (arg == NULL) {
-				Py_DECREF(item);
-				goto Fail_1;
-			}
-			good = PyEval_CallObject(func, arg);
-			Py_DECREF(arg);
-			if (good == NULL) {
-				Py_DECREF(item);
-				goto Fail_1;
-			}
-			ok = PyObject_IsTrue(good);
-			Py_DECREF(good);
-		}
-		if (ok) {
-			Py_ssize_t reslen;
-			if (!PyUnicode_Check(item)) {
-				PyErr_SetString(PyExc_TypeError,
-				"can't filter unicode to unicode:"
-				" __getitem__ returned different type");
-				Py_DECREF(item);
-				goto Fail_1;
-			}
-			reslen = PyUnicode_GET_SIZE(item);
-			if (reslen == 1)
-				PyUnicode_AS_UNICODE(result)[j++] =
-					PyUnicode_AS_UNICODE(item)[0];
-			else {
-				/* do we need more space? */
-				Py_ssize_t need = j + reslen + len - i - 1;
-        
-				/* check that didnt overflow */
-				if ((j > PY_SSIZE_T_MAX - reslen) ||
-					((j + reslen) > PY_SSIZE_T_MAX - len) ||
-						((j + reslen + len) < i) ||
-							((j + reslen + len - i) <= 0)) {
-					Py_DECREF(item);
-					return NULL;
-				}
-
-				assert(need >= 0);
-				assert(outlen >= 0);
-				
-				if (need > outlen) {
-					/* overallocate,
-					   to avoid reallocations */
-					if (need < 2 * outlen) {
-            if (outlen > PY_SSIZE_T_MAX / 2) {
-              Py_DECREF(item);
-              return NULL;
-						} else {
-							need = 2 * outlen;
-				    }
-          }
-
-					if (PyUnicode_Resize(
-						&result, need) < 0) {
-						Py_DECREF(item);
-						goto Fail_1;
-					}
-					outlen = need;
-				}
-				memcpy(PyUnicode_AS_UNICODE(result) + j,
-				       PyUnicode_AS_UNICODE(item),
-				       reslen*sizeof(Py_UNICODE));
-				j += reslen;
-			}
-		}
-		Py_DECREF(item);
-	}
-
-	if (j < outlen)
-		PyUnicode_Resize(&result, j);
-
-	return result;
+    PyObject *result;
+    register Py_ssize_t i, j;
+    Py_ssize_t len = PyUnicode_GetSize(strobj);
+    Py_ssize_t outlen = len;
+
+    if (func == Py_None) {
+        /* If it's a real string we can return the original,
+         * as no character is ever false and __getitem__
+         * does return this character. If it's a subclass
+         * we must go through the __getitem__ loop */
+        if (PyUnicode_CheckExact(strobj)) {
+            Py_INCREF(strobj);
+            return strobj;
+        }
+    }
+    if ((result = PyUnicode_FromUnicode(NULL, len)) == NULL)
+        return NULL;
+
+    for (i = j = 0; i < len; ++i) {
+        PyObject *item, *arg, *good;
+        int ok;
+
+        item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
+        if (item == NULL)
+            goto Fail_1;
+        if (func == Py_None) {
+            ok = 1;
+        } else {
+            arg = PyTuple_Pack(1, item);
+            if (arg == NULL) {
+                Py_DECREF(item);
+                goto Fail_1;
+            }
+            good = PyEval_CallObject(func, arg);
+            Py_DECREF(arg);
+            if (good == NULL) {
+                Py_DECREF(item);
+                goto Fail_1;
+            }
+            ok = PyObject_IsTrue(good);
+            Py_DECREF(good);
+        }
+        if (ok) {
+            Py_ssize_t reslen;
+            if (!PyUnicode_Check(item)) {
+                PyErr_SetString(PyExc_TypeError,
+                "can't filter unicode to unicode:"
+                " __getitem__ returned different type");
+                Py_DECREF(item);
+                goto Fail_1;
+            }
+            reslen = PyUnicode_GET_SIZE(item);
+            if (reslen == 1)
+                PyUnicode_AS_UNICODE(result)[j++] =
+                    PyUnicode_AS_UNICODE(item)[0];
+            else {
+                /* do we need more space? */
+                Py_ssize_t need = j + reslen + len - i - 1;
+
+                /* check that didnt overflow */
+                if ((j > PY_SSIZE_T_MAX - reslen) ||
+                    ((j + reslen) > PY_SSIZE_T_MAX - len) ||
+                        ((j + reslen + len) < i) ||
+                            ((j + reslen + len - i) <= 0)) {
+                    Py_DECREF(item);
+                    return NULL;
+                }
+
+                assert(need >= 0);
+                assert(outlen >= 0);
+
+                if (need > outlen) {
+                    /* overallocate,
+                       to avoid reallocations */
+                    if (need < 2 * outlen) {
+        if (outlen > PY_SSIZE_T_MAX / 2) {
+          Py_DECREF(item);
+          return NULL;
+                                            } else {
+                                                    need = 2 * outlen;
+                                }
+      }
+
+                                    if (PyUnicode_Resize(
+                                            &result, need) < 0) {
+                                            Py_DECREF(item);
+                                            goto Fail_1;
+                                    }
+                                    outlen = need;
+                            }
+                            memcpy(PyUnicode_AS_UNICODE(result) + j,
+                                   PyUnicode_AS_UNICODE(item),
+                                   reslen*sizeof(Py_UNICODE));
+                            j += reslen;
+                    }
+        }
+        Py_DECREF(item);
+    }
+
+    if (j < outlen)
+        PyUnicode_Resize(&result, j);
+
+    return result;
 
 Fail_1:
-	Py_DECREF(result);
-	return NULL;
+    Py_DECREF(result);
+    return NULL;
 }
 #endif
diff --git a/Python/ceval.c b/Python/ceval.c
index 2b64cae..a27cfc1 100644
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -28,27 +28,27 @@
 typedef unsigned long long uint64;
 
 #if defined(__ppc__) /* <- Don't know if this is the correct symbol; this
-			   section should work for GCC on any PowerPC
-			   platform, irrespective of OS.
-			   POWER?  Who knows :-) */
+                           section should work for GCC on any PowerPC
+                           platform, irrespective of OS.
+                           POWER?  Who knows :-) */
 
 #define READ_TIMESTAMP(var) ppc_getcounter(&var)
 
 static void
 ppc_getcounter(uint64 *v)
 {
-	register unsigned long tbu, tb, tbu2;
+    register unsigned long tbu, tb, tbu2;
 
   loop:
-	asm volatile ("mftbu %0" : "=r" (tbu) );
-	asm volatile ("mftb  %0" : "=r" (tb)  );
-	asm volatile ("mftbu %0" : "=r" (tbu2));
-	if (__builtin_expect(tbu != tbu2, 0)) goto loop;
-
-	/* The slightly peculiar way of writing the next lines is
-	   compiled better by GCC than any other way I tried. */
-	((long*)(v))[0] = tbu;
-	((long*)(v))[1] = tb;
+    asm volatile ("mftbu %0" : "=r" (tbu) );
+    asm volatile ("mftb  %0" : "=r" (tb)  );
+    asm volatile ("mftbu %0" : "=r" (tbu2));
+    if (__builtin_expect(tbu != tbu2, 0)) goto loop;
+
+    /* The slightly peculiar way of writing the next lines is
+       compiled better by GCC than any other way I tried. */
+    ((long*)(v))[0] = tbu;
+    ((long*)(v))[1] = tb;
 }
 
 #elif defined(__i386__)
@@ -77,17 +77,17 @@ ppc_getcounter(uint64 *v)
 #endif
 
 void dump_tsc(int opcode, int ticked, uint64 inst0, uint64 inst1,
-	      uint64 loop0, uint64 loop1, uint64 intr0, uint64 intr1)
+              uint64 loop0, uint64 loop1, uint64 intr0, uint64 intr1)
 {
-	uint64 intr, inst, loop;
-	PyThreadState *tstate = PyThreadState_Get();
-	if (!tstate->interp->tscdump)
-		return;
-	intr = intr1 - intr0;
-	inst = inst1 - inst0 - intr;
-	loop = loop1 - loop0 - intr;
-	fprintf(stderr, "opcode=%03d t=%d inst=%06lld loop=%06lld\n",
-		opcode, ticked, inst, loop);
+    uint64 intr, inst, loop;
+    PyThreadState *tstate = PyThreadState_Get();
+    if (!tstate->interp->tscdump)
+        return;
+    intr = intr1 - intr0;
+    inst = inst1 - inst0 - intr;
+    loop = loop1 - loop0 - intr;
+    fprintf(stderr, "opcode=%03d t=%d inst=%06lld loop=%06lld\n",
+        opcode, ticked, inst, loop);
 }
 
 #endif
@@ -97,8 +97,8 @@ void dump_tsc(int opcode, int ticked, uint64 inst0, uint64 inst1,
 
 #ifdef Py_DEBUG
 /* For debugging the interpreter: */
-#define LLTRACE  1	/* Low-level trace feature */
-#define CHECKEXC 1	/* Double-check exception checking */
+#define LLTRACE  1      /* Low-level trace feature */
+#define CHECKEXC 1      /* Double-check exception checking */
 #endif
 
 typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);
@@ -113,7 +113,7 @@ static PyObject * fast_function(PyObject *, PyObject ***, int, int, int);
 static PyObject * do_call(PyObject *, PyObject ***, int, int);
 static PyObject * ext_do_call(PyObject *, PyObject ***, int, int, int);
 static PyObject * update_keyword_args(PyObject *, int, PyObject ***,
-				      PyObject *);
+                                      PyObject *);
 static PyObject * update_star_args(int, int, PyObject *, PyObject ***);
 static PyObject * load_args(PyObject ***, int);
 #define CALL_FLAG_VAR 1
@@ -124,39 +124,39 @@ static int lltrace;
 static int prtrace(PyObject *, char *);
 #endif
 static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *,
-		      int, PyObject *);
+                      int, PyObject *);
 static int call_trace_protected(Py_tracefunc, PyObject *,
-				 PyFrameObject *, int, PyObject *);
+                                 PyFrameObject *, int, PyObject *);
 static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *);
 static int maybe_call_line_trace(Py_tracefunc, PyObject *,
-				  PyFrameObject *, int *, int *, int *);
+                                  PyFrameObject *, int *, int *, int *);
 
 static PyObject * apply_slice(PyObject *, PyObject *, PyObject *);
 static int assign_slice(PyObject *, PyObject *,
-			PyObject *, PyObject *);
+                        PyObject *, PyObject *);
 static PyObject * cmp_outcome(int, PyObject *, PyObject *);
 static PyObject * import_from(PyObject *, PyObject *);
 static int import_all_from(PyObject *, PyObject *);
 static PyObject * build_class(PyObject *, PyObject *, PyObject *);
 static int exec_statement(PyFrameObject *,
-			  PyObject *, PyObject *, PyObject *);
+                          PyObject *, PyObject *, PyObject *);
 static void set_exc_info(PyThreadState *, PyObject *, PyObject *, PyObject *);
 static void reset_exc_info(PyThreadState *);
 static void format_exc_check_arg(PyObject *, char *, PyObject *);
 static PyObject * string_concatenate(PyObject *, PyObject *,
-				    PyFrameObject *, unsigned char *);
+                                    PyFrameObject *, unsigned char *);
 static PyObject * kwd_as_string(PyObject *);
 static PyObject * special_lookup(PyObject *, char *, PyObject **);
 
 #define NAME_ERROR_MSG \
-	"name '%.200s' is not defined"
+    "name '%.200s' is not defined"
 #define GLOBAL_NAME_ERROR_MSG \
-	"global name '%.200s' is not defined"
+    "global name '%.200s' is not defined"
 #define UNBOUNDLOCAL_ERROR_MSG \
-	"local variable '%.200s' referenced before assignment"
+    "local variable '%.200s' referenced before assignment"
 #define UNBOUNDFREE_ERROR_MSG \
-	"free variable '%.200s' referenced before assignment" \
-        " in enclosing scope"
+    "free variable '%.200s' referenced before assignment" \
+    " in enclosing scope"
 
 /* Dynamic execution profile */
 #ifdef DYNAMIC_EXECUTION_PROFILE
@@ -208,10 +208,10 @@ static int pcall[PCALL_NUM];
 PyObject *
 PyEval_GetCallStats(PyObject *self)
 {
-	return Py_BuildValue("iiiiiiiiiii",
-			     pcall[0], pcall[1], pcall[2], pcall[3],
-			     pcall[4], pcall[5], pcall[6], pcall[7],
-			     pcall[8], pcall[9], pcall[10]);
+    return Py_BuildValue("iiiiiiiiiii",
+                         pcall[0], pcall[1], pcall[2], pcall[3],
+                         pcall[4], pcall[5], pcall[6], pcall[7],
+                         pcall[8], pcall[9], pcall[10]);
 }
 #else
 #define PCALL(O)
@@ -219,8 +219,8 @@ PyEval_GetCallStats(PyObject *self)
 PyObject *
 PyEval_GetCallStats(PyObject *self)
 {
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 #endif
 
@@ -239,52 +239,52 @@ static long main_thread = 0;
 int
 PyEval_ThreadsInitialized(void)
 {
-	return interpreter_lock != 0;
+    return interpreter_lock != 0;
 }
 
 void
 PyEval_InitThreads(void)
 {
-	if (interpreter_lock)
-		return;
-	interpreter_lock = PyThread_allocate_lock();
-	PyThread_acquire_lock(interpreter_lock, 1);
-	main_thread = PyThread_get_thread_ident();
+    if (interpreter_lock)
+        return;
+    interpreter_lock = PyThread_allocate_lock();
+    PyThread_acquire_lock(interpreter_lock, 1);
+    main_thread = PyThread_get_thread_ident();
 }
 
 void
 PyEval_AcquireLock(void)
 {
-	PyThread_acquire_lock(interpreter_lock, 1);
+    PyThread_acquire_lock(interpreter_lock, 1);
 }
 
 void
 PyEval_ReleaseLock(void)
 {
-	PyThread_release_lock(interpreter_lock);
+    PyThread_release_lock(interpreter_lock);
 }
 
 void
 PyEval_AcquireThread(PyThreadState *tstate)
 {
-	if (tstate == NULL)
-		Py_FatalError("PyEval_AcquireThread: NULL new thread state");
-	/* Check someone has called PyEval_InitThreads() to create the lock */
-	assert(interpreter_lock);
-	PyThread_acquire_lock(interpreter_lock, 1);
-	if (PyThreadState_Swap(tstate) != NULL)
-		Py_FatalError(
-			"PyEval_AcquireThread: non-NULL old thread state");
+    if (tstate == NULL)
+        Py_FatalError("PyEval_AcquireThread: NULL new thread state");
+    /* Check someone has called PyEval_InitThreads() to create the lock */
+    assert(interpreter_lock);
+    PyThread_acquire_lock(interpreter_lock, 1);
+    if (PyThreadState_Swap(tstate) != NULL)
+        Py_FatalError(
+            "PyEval_AcquireThread: non-NULL old thread state");
 }
 
 void
 PyEval_ReleaseThread(PyThreadState *tstate)
 {
-	if (tstate == NULL)
-		Py_FatalError("PyEval_ReleaseThread: NULL thread state");
-	if (PyThreadState_Swap(NULL) != tstate)
-		Py_FatalError("PyEval_ReleaseThread: wrong thread state");
-	PyThread_release_lock(interpreter_lock);
+    if (tstate == NULL)
+        Py_FatalError("PyEval_ReleaseThread: NULL thread state");
+    if (PyThreadState_Swap(NULL) != tstate)
+        Py_FatalError("PyEval_ReleaseThread: wrong thread state");
+    PyThread_release_lock(interpreter_lock);
 }
 
 /* This function is called from PyOS_AfterFork to ensure that newly
@@ -295,36 +295,36 @@ PyEval_ReleaseThread(PyThreadState *tstate)
 void
 PyEval_ReInitThreads(void)
 {
-	PyObject *threading, *result;
-	PyThreadState *tstate;
-
-	if (!interpreter_lock)
-		return;
-	/*XXX Can't use PyThread_free_lock here because it does too
-	  much error-checking.  Doing this cleanly would require
-	  adding a new function to each thread_*.h.  Instead, just
-	  create a new lock and waste a little bit of memory */
-	interpreter_lock = PyThread_allocate_lock();
-	pending_lock = PyThread_allocate_lock();
-	PyThread_acquire_lock(interpreter_lock, 1);
-	main_thread = PyThread_get_thread_ident();
-
-	/* Update the threading module with the new state.
-	 */
-	tstate = PyThreadState_GET();
-	threading = PyMapping_GetItemString(tstate->interp->modules,
-					    "threading");
-	if (threading == NULL) {
-		/* threading not imported */
-		PyErr_Clear();
-		return;
-	}
-	result = PyObject_CallMethod(threading, "_after_fork", NULL);
-	if (result == NULL)
-		PyErr_WriteUnraisable(threading);
-	else
-		Py_DECREF(result);
-	Py_DECREF(threading);
+    PyObject *threading, *result;
+    PyThreadState *tstate;
+
+    if (!interpreter_lock)
+        return;
+    /*XXX Can't use PyThread_free_lock here because it does too
+      much error-checking.  Doing this cleanly would require
+      adding a new function to each thread_*.h.  Instead, just
+      create a new lock and waste a little bit of memory */
+    interpreter_lock = PyThread_allocate_lock();
+    pending_lock = PyThread_allocate_lock();
+    PyThread_acquire_lock(interpreter_lock, 1);
+    main_thread = PyThread_get_thread_ident();
+
+    /* Update the threading module with the new state.
+     */
+    tstate = PyThreadState_GET();
+    threading = PyMapping_GetItemString(tstate->interp->modules,
+                                        "threading");
+    if (threading == NULL) {
+        /* threading not imported */
+        PyErr_Clear();
+        return;
+    }
+    result = PyObject_CallMethod(threading, "_after_fork", NULL);
+    if (result == NULL)
+        PyErr_WriteUnraisable(threading);
+    else
+        Py_DECREF(result);
+    Py_DECREF(threading);
 }
 #endif
 
@@ -335,29 +335,29 @@ PyEval_ReInitThreads(void)
 PyThreadState *
 PyEval_SaveThread(void)
 {
-	PyThreadState *tstate = PyThreadState_Swap(NULL);
-	if (tstate == NULL)
-		Py_FatalError("PyEval_SaveThread: NULL tstate");
+    PyThreadState *tstate = PyThreadState_Swap(NULL);
+    if (tstate == NULL)
+        Py_FatalError("PyEval_SaveThread: NULL tstate");
 #ifdef WITH_THREAD
-	if (interpreter_lock)
-		PyThread_release_lock(interpreter_lock);
+    if (interpreter_lock)
+        PyThread_release_lock(interpreter_lock);
 #endif
-	return tstate;
+    return tstate;
 }
 
 void
 PyEval_RestoreThread(PyThreadState *tstate)
 {
-	if (tstate == NULL)
-		Py_FatalError("PyEval_RestoreThread: NULL tstate");
+    if (tstate == NULL)
+        Py_FatalError("PyEval_RestoreThread: NULL tstate");
 #ifdef WITH_THREAD
-	if (interpreter_lock) {
-		int err = errno;
-		PyThread_acquire_lock(interpreter_lock, 1);
-		errno = err;
-	}
+    if (interpreter_lock) {
+        int err = errno;
+        PyThread_acquire_lock(interpreter_lock, 1);
+        errno = err;
+    }
 #endif
-	PyThreadState_Swap(tstate);
+    PyThreadState_Swap(tstate);
 }
 
 
@@ -394,8 +394,8 @@ PyEval_RestoreThread(PyThreadState *tstate)
 
 #define NPENDINGCALLS 32
 static struct {
-	int (*func)(void *);
-	void *arg;
+    int (*func)(void *);
+    void *arg;
 } pendingcalls[NPENDINGCALLS];
 static int pendingfirst = 0;
 static int pendinglast = 0;
@@ -405,93 +405,93 @@ static char pendingbusy = 0;
 int
 Py_AddPendingCall(int (*func)(void *), void *arg)
 {
-	int i, j, result=0;
-	PyThread_type_lock lock = pending_lock;
-	
-	/* try a few times for the lock.  Since this mechanism is used
-	 * for signal handling (on the main thread), there is a (slim)
-	 * chance that a signal is delivered on the same thread while we
-	 * hold the lock during the Py_MakePendingCalls() function.
-	 * This avoids a deadlock in that case.
-	 * Note that signals can be delivered on any thread.  In particular,
-	 * on Windows, a SIGINT is delivered on a system-created worker
-	 * thread.
-	 * We also check for lock being NULL, in the unlikely case that
-	 * this function is called before any bytecode evaluation takes place.
-	 */
-	if (lock != NULL) {
-		for (i = 0; i<100; i++) {
-			if (PyThread_acquire_lock(lock, NOWAIT_LOCK))
-				break;
-		}
-		if (i == 100)
-			return -1;
-	}
-
-	i = pendinglast;
-	j = (i + 1) % NPENDINGCALLS;
-	if (j == pendingfirst) {
-		result = -1; /* Queue full */
-	} else {
-		pendingcalls[i].func = func;
-		pendingcalls[i].arg = arg;
-		pendinglast = j;
-	}
-	/* signal main loop */
-	_Py_Ticker = 0;
-	pendingcalls_to_do = 1;
-	if (lock != NULL)
-		PyThread_release_lock(lock);
-	return result;
+    int i, j, result=0;
+    PyThread_type_lock lock = pending_lock;
+
+    /* try a few times for the lock.  Since this mechanism is used
+     * for signal handling (on the main thread), there is a (slim)
+     * chance that a signal is delivered on the same thread while we
+     * hold the lock during the Py_MakePendingCalls() function.
+     * This avoids a deadlock in that case.
+     * Note that signals can be delivered on any thread.  In particular,
+     * on Windows, a SIGINT is delivered on a system-created worker
+     * thread.
+     * We also check for lock being NULL, in the unlikely case that
+     * this function is called before any bytecode evaluation takes place.
+     */
+    if (lock != NULL) {
+        for (i = 0; i<100; i++) {
+            if (PyThread_acquire_lock(lock, NOWAIT_LOCK))
+                break;
+        }
+        if (i == 100)
+            return -1;
+    }
+
+    i = pendinglast;
+    j = (i + 1) % NPENDINGCALLS;
+    if (j == pendingfirst) {
+        result = -1; /* Queue full */
+    } else {
+        pendingcalls[i].func = func;
+        pendingcalls[i].arg = arg;
+        pendinglast = j;
+    }
+    /* signal main loop */
+    _Py_Ticker = 0;
+    pendingcalls_to_do = 1;
+    if (lock != NULL)
+        PyThread_release_lock(lock);
+    return result;
 }
 
 int
 Py_MakePendingCalls(void)
 {
-	int i;
-	int r = 0;
-
-	if (!pending_lock) {
-		/* initial allocation of the lock */
-		pending_lock = PyThread_allocate_lock();
-		if (pending_lock == NULL)
-			return -1;
-	}
-
-	/* only service pending calls on main thread */
-	if (main_thread && PyThread_get_thread_ident() != main_thread)
-		return 0; 
-	/* don't perform recursive pending calls */
-	if (pendingbusy)
-		return 0;
-	pendingbusy = 1;
-	/* perform a bounded number of calls, in case of recursion */
-	for (i=0; i<NPENDINGCALLS; i++) {
-		int j;  
-		int (*func)(void *);
-		void *arg = NULL;
-		
-		/* pop one item off the queue while holding the lock */
-		PyThread_acquire_lock(pending_lock, WAIT_LOCK);
-		j = pendingfirst;
-		if (j == pendinglast) {
-			func = NULL; /* Queue empty */
-		} else {
-			func = pendingcalls[j].func;
-			arg = pendingcalls[j].arg;
-			pendingfirst = (j + 1) % NPENDINGCALLS;
-		}
-		pendingcalls_to_do = pendingfirst != pendinglast;
-		PyThread_release_lock(pending_lock);
-		/* having released the lock, perform the callback */
-		if (func == NULL)
-			break;
-		r = func(arg);
-		if (r)
-			break;
-	}
-	pendingbusy = 0;
-	return r;
+    int i;
+    int r = 0;
+
+    if (!pending_lock) {
+        /* initial allocation of the lock */
+        pending_lock = PyThread_allocate_lock();
+        if (pending_lock == NULL)
+            return -1;
+    }
+
+    /* only service pending calls on main thread */
+    if (main_thread && PyThread_get_thread_ident() != main_thread)
+        return 0;
+    /* don't perform recursive pending calls */
+    if (pendingbusy)
+        return 0;
+    pendingbusy = 1;
+    /* perform a bounded number of calls, in case of recursion */
+    for (i=0; i<NPENDINGCALLS; i++) {
+        int j;
+        int (*func)(void *);
+        void *arg = NULL;
+
+        /* pop one item off the queue while holding the lock */
+        PyThread_acquire_lock(pending_lock, WAIT_LOCK);
+        j = pendingfirst;
+        if (j == pendinglast) {
+            func = NULL; /* Queue empty */
+        } else {
+            func = pendingcalls[j].func;
+            arg = pendingcalls[j].arg;
+            pendingfirst = (j + 1) % NPENDINGCALLS;
+        }
+        pendingcalls_to_do = pendingfirst != pendinglast;
+        PyThread_release_lock(pending_lock);
+        /* having released the lock, perform the callback */
+        if (func == NULL)
+            break;
+        r = func(arg);
+        if (r)
+            break;
+    }
+    pendingbusy = 0;
+    return r;
 }
 
 #else /* if ! defined WITH_THREAD */
@@ -502,11 +502,11 @@ Py_MakePendingCalls(void)
    with WITH_THREAD.
    Don't use this implementation when Py_AddPendingCalls() can happen
    on a different thread!
- 
+
    There are two possible race conditions:
    (1) nested asynchronous calls to Py_AddPendingCall()
    (2) AddPendingCall() calls made while pending calls are being processed.
-   
+
    (1) is very unlikely because typically signal delivery
    is blocked during signal handling.  So it should be impossible.
    (2) is a real possibility.
@@ -521,8 +521,8 @@ Py_MakePendingCalls(void)
 
 #define NPENDINGCALLS 32
 static struct {
-	int (*func)(void *);
-	void *arg;
+    int (*func)(void *);
+    void *arg;
 } pendingcalls[NPENDINGCALLS];
 static volatile int pendingfirst = 0;
 static volatile int pendinglast = 0;
@@ -531,55 +531,55 @@ static volatile int pendingcalls_to_do = 0;
 int
 Py_AddPendingCall(int (*func)(void *), void *arg)
 {
-	static volatile int busy = 0;
-	int i, j;
-	/* XXX Begin critical section */
-	if (busy)
-		return -1;
-	busy = 1;
-	i = pendinglast;
-	j = (i + 1) % NPENDINGCALLS;
-	if (j == pendingfirst) {
-		busy = 0;
-		return -1; /* Queue full */
-	}
-	pendingcalls[i].func = func;
-	pendingcalls[i].arg = arg;
-	pendinglast = j;
-
-	_Py_Ticker = 0;
-	pendingcalls_to_do = 1; /* Signal main loop */
-	busy = 0;
-	/* XXX End critical section */
-	return 0;
+    static volatile int busy = 0;
+    int i, j;
+    /* XXX Begin critical section */
+    if (busy)
+        return -1;
+    busy = 1;
+    i = pendinglast;
+    j = (i + 1) % NPENDINGCALLS;
+    if (j == pendingfirst) {
+        busy = 0;
+        return -1; /* Queue full */
+    }
+    pendingcalls[i].func = func;
+    pendingcalls[i].arg = arg;
+    pendinglast = j;
+
+    _Py_Ticker = 0;
+    pendingcalls_to_do = 1; /* Signal main loop */
+    busy = 0;
+    /* XXX End critical section */
+    return 0;
 }
 
 int
 Py_MakePendingCalls(void)
 {
-	static int busy = 0;
-	if (busy)
-		return 0;
-	busy = 1;
-	pendingcalls_to_do = 0;
-	for (;;) {
-		int i;
-		int (*func)(void *);
-		void *arg;
-		i = pendingfirst;
-		if (i == pendinglast)
-			break; /* Queue empty */
-		func = pendingcalls[i].func;
-		arg = pendingcalls[i].arg;
-		pendingfirst = (i + 1) % NPENDINGCALLS;
-		if (func(arg) < 0) {
-			busy = 0;
-			pendingcalls_to_do = 1; /* We're not done yet */
-			return -1;
-		}
-	}
-	busy = 0;
-	return 0;
+    static int busy = 0;
+    if (busy)
+        return 0;
+    busy = 1;
+    pendingcalls_to_do = 0;
+    for (;;) {
+        int i;
+        int (*func)(void *);
+        void *arg;
+        i = pendingfirst;
+        if (i == pendinglast)
+            break; /* Queue empty */
+        func = pendingcalls[i].func;
+        arg = pendingcalls[i].arg;
+        pendingfirst = (i + 1) % NPENDINGCALLS;
+        if (func(arg) < 0) {
+            busy = 0;
+            pendingcalls_to_do = 1; /* We're not done yet */
+            return -1;
+        }
+    }
+    busy = 0;
+    return 0;
 }
 
 #endif /* WITH_THREAD */
@@ -596,14 +596,14 @@ int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;
 int
 Py_GetRecursionLimit(void)
 {
-	return recursion_limit;
+    return recursion_limit;
 }
 
 void
 Py_SetRecursionLimit(int new_limit)
 {
-	recursion_limit = new_limit;
-	_Py_CheckRecursionLimit = recursion_limit;
+    recursion_limit = new_limit;
+    _Py_CheckRecursionLimit = recursion_limit;
 }
 
 /* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()
@@ -614,35 +614,35 @@ Py_SetRecursionLimit(int new_limit)
 int
 _Py_CheckRecursiveCall(char *where)
 {
-	PyThreadState *tstate = PyThreadState_GET();
+    PyThreadState *tstate = PyThreadState_GET();
 
 #ifdef USE_STACKCHECK
-	if (PyOS_CheckStack()) {
-		--tstate->recursion_depth;
-		PyErr_SetString(PyExc_MemoryError, "Stack overflow");
-		return -1;
-	}
+    if (PyOS_CheckStack()) {
+        --tstate->recursion_depth;
+        PyErr_SetString(PyExc_MemoryError, "Stack overflow");
+        return -1;
+    }
 #endif
-	if (tstate->recursion_depth > recursion_limit) {
-		--tstate->recursion_depth;
-		PyErr_Format(PyExc_RuntimeError,
-			     "maximum recursion depth exceeded%s",
-			     where);
-		return -1;
-	}
-	_Py_CheckRecursionLimit = recursion_limit;
-	return 0;
+    if (tstate->recursion_depth > recursion_limit) {
+        --tstate->recursion_depth;
+        PyErr_Format(PyExc_RuntimeError,
+                     "maximum recursion depth exceeded%s",
+                     where);
+        return -1;
+    }
+    _Py_CheckRecursionLimit = recursion_limit;
+    return 0;
 }
 
 /* Status code for main loop (reason for stack unwind) */
 enum why_code {
-		WHY_NOT =	0x0001,	/* No error */
-		WHY_EXCEPTION = 0x0002,	/* Exception occurred */
-		WHY_RERAISE =	0x0004,	/* Exception re-raised by 'finally' */
-		WHY_RETURN =	0x0008,	/* 'return' statement */
-		WHY_BREAK =	0x0010,	/* 'break' statement */
-		WHY_CONTINUE =	0x0020,	/* 'continue' statement */
-		WHY_YIELD =	0x0040	/* 'yield' operator */
+                WHY_NOT =       0x0001, /* No error */
+        WHY_EXCEPTION = 0x0002,         /* Exception occurred */
+        WHY_RERAISE =           0x0004, /* Exception re-raised by 'finally' */
+        WHY_RETURN =            0x0008, /* 'return' statement */
+        WHY_BREAK =             0x0010, /* 'break' statement */
+        WHY_CONTINUE =          0x0020, /* 'continue' statement */
+        WHY_YIELD =             0x0040  /* 'yield' operator */
 };
 
 static enum why_code do_raise(PyObject *, PyObject *, PyObject *);
@@ -663,12 +663,12 @@ volatile int _Py_Ticker = 0; /* so that we hit a "tick" first thing */
 PyObject *
 PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
 {
-	return PyEval_EvalCodeEx(co,
-			  globals, locals,
-			  (PyObject **)NULL, 0,
-			  (PyObject **)NULL, 0,
-			  (PyObject **)NULL, 0,
-			  NULL);
+    return PyEval_EvalCodeEx(co,
+                      globals, locals,
+                      (PyObject **)NULL, 0,
+                      (PyObject **)NULL, 0,
+                      (PyObject **)NULL, 0,
+                      NULL);
 }
 
 
@@ -676,50 +676,50 @@ PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
 
 PyObject *
 PyEval_EvalFrame(PyFrameObject *f) {
-	/* This is for backward compatibility with extension modules that
-           used this API; core interpreter code should call
-           PyEval_EvalFrameEx() */
-	return PyEval_EvalFrameEx(f, 0);
+    /* This is for backward compatibility with extension modules that
+       used this API; core interpreter code should call
+       PyEval_EvalFrameEx() */
+    return PyEval_EvalFrameEx(f, 0);
 }
 
 PyObject *
 PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
 {
 #ifdef DXPAIRS
-	int lastopcode = 0;
+    int lastopcode = 0;
 #endif
-	register PyObject **stack_pointer;  /* Next free slot in value stack */
-	register unsigned char *next_instr;
-	register int opcode;	/* Current opcode */
-	register int oparg;	/* Current opcode argument, if any */
-	register enum why_code why; /* Reason for block stack unwind */
-	register int err;	/* Error status -- nonzero if error */
-	register PyObject *x;	/* Result object -- NULL if error */
-	register PyObject *v;	/* Temporary objects popped off stack */
-	register PyObject *w;
-	register PyObject *u;
-	register PyObject *t;
-	register PyObject *stream = NULL;    /* for PRINT opcodes */
-	register PyObject **fastlocals, **freevars;
-	PyObject *retval = NULL;	/* Return value */
-	PyThreadState *tstate = PyThreadState_GET();
-	PyCodeObject *co;
-
-	/* when tracing we set things up so that
-
-               not (instr_lb <= current_bytecode_offset < instr_ub)
-
-	   is true when the line being executed has changed.  The
-           initial values are such as to make this false the first
-           time it is tested. */
-	int instr_ub = -1, instr_lb = 0, instr_prev = -1;
-
-	unsigned char *first_instr;
-	PyObject *names;
-	PyObject *consts;
+    register PyObject **stack_pointer;  /* Next free slot in value stack */
+    register unsigned char *next_instr;
+    register int opcode;        /* Current opcode */
+    register int oparg;         /* Current opcode argument, if any */
+    register enum why_code why; /* Reason for block stack unwind */
+    register int err;           /* Error status -- nonzero if error */
+    register PyObject *x;       /* Result object -- NULL if error */
+    register PyObject *v;       /* Temporary objects popped off stack */
+    register PyObject *w;
+    register PyObject *u;
+    register PyObject *t;
+    register PyObject *stream = NULL;    /* for PRINT opcodes */
+    register PyObject **fastlocals, **freevars;
+    PyObject *retval = NULL;            /* Return value */
+    PyThreadState *tstate = PyThreadState_GET();
+    PyCodeObject *co;
+
+    /* when tracing we set things up so that
+
+           not (instr_lb <= current_bytecode_offset < instr_ub)
+
+       is true when the line being executed has changed.  The
+       initial values are such as to make this false the first
+       time it is tested. */
+    int instr_ub = -1, instr_lb = 0, instr_prev = -1;
+
+    unsigned char *first_instr;
+    PyObject *names;
+    PyObject *consts;
 #if defined(Py_DEBUG) || defined(LLTRACE)
-	/* Make it easier to find out where we are with a debugger */
-	char *filename;
+    /* Make it easier to find out where we are with a debugger */
+    char *filename;
 #endif
 
 /* Tuple access macros */
@@ -759,100 +759,100 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
    CALL_FUNCTION (and friends)
 
  */
-	uint64 inst0, inst1, loop0, loop1, intr0 = 0, intr1 = 0;
-	int ticked = 0;
+    uint64 inst0, inst1, loop0, loop1, intr0 = 0, intr1 = 0;
+    int ticked = 0;
 
-	READ_TIMESTAMP(inst0);
-	READ_TIMESTAMP(inst1);
-	READ_TIMESTAMP(loop0);
-	READ_TIMESTAMP(loop1);
+    READ_TIMESTAMP(inst0);
+    READ_TIMESTAMP(inst1);
+    READ_TIMESTAMP(loop0);
+    READ_TIMESTAMP(loop1);
 
-	/* shut up the compiler */
-	opcode = 0;
+    /* shut up the compiler */
+    opcode = 0;
 #endif
 
 /* Code access macros */
 
-#define INSTR_OFFSET()	((int)(next_instr - first_instr))
-#define NEXTOP()	(*next_instr++)
-#define NEXTARG()	(next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
-#define PEEKARG()	((next_instr[2]<<8) + next_instr[1])
-#define JUMPTO(x)	(next_instr = first_instr + (x))
-#define JUMPBY(x)	(next_instr += (x))
+#define INSTR_OFFSET()  ((int)(next_instr - first_instr))
+#define NEXTOP()        (*next_instr++)
+#define NEXTARG()       (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
+#define PEEKARG()       ((next_instr[2]<<8) + next_instr[1])
+#define JUMPTO(x)       (next_instr = first_instr + (x))
+#define JUMPBY(x)       (next_instr += (x))
 
 /* OpCode prediction macros
-	Some opcodes tend to come in pairs thus making it possible to
-	predict the second code when the first is run.  For example,
-	GET_ITER is often followed by FOR_ITER. And FOR_ITER is often
-	followed by STORE_FAST or UNPACK_SEQUENCE.
-
-	Verifying the prediction costs a single high-speed test of a register
-	variable against a constant.  If the pairing was good, then the
-	processor's own internal branch predication has a high likelihood of
-	success, resulting in a nearly zero-overhead transition to the
-	next opcode.  A successful prediction saves a trip through the eval-loop
-	including its two unpredictable branches, the HAS_ARG test and the
-	switch-case.  Combined with the processor's internal branch prediction,
-	a successful PREDICT has the effect of making the two opcodes run as if
-	they were a single new opcode with the bodies combined.
+    Some opcodes tend to come in pairs thus making it possible to
+    predict the second code when the first is run.  For example,
+    GET_ITER is often followed by FOR_ITER. And FOR_ITER is often
+    followed by STORE_FAST or UNPACK_SEQUENCE.
+
+    Verifying the prediction costs a single high-speed test of a register
+    variable against a constant.  If the pairing was good, then the
+    processor's own internal branch predication has a high likelihood of
+    success, resulting in a nearly zero-overhead transition to the
+    next opcode.  A successful prediction saves a trip through the eval-loop
+    including its two unpredictable branches, the HAS_ARG test and the
+    switch-case.  Combined with the processor's internal branch prediction,
+    a successful PREDICT has the effect of making the two opcodes run as if
+    they were a single new opcode with the bodies combined.
 
     If collecting opcode statistics, your choices are to either keep the
-	predictions turned-on and interpret the results as if some opcodes
-	had been combined or turn-off predictions so that the opcode frequency
-	counter updates for both opcodes.
+    predictions turned-on and interpret the results as if some opcodes
+    had been combined or turn-off predictions so that the opcode frequency
+    counter updates for both opcodes.
 */
 
 #ifdef DYNAMIC_EXECUTION_PROFILE
-#define PREDICT(op)		if (0) goto PRED_##op
+#define PREDICT(op)             if (0) goto PRED_##op
 #else
-#define PREDICT(op)		if (*next_instr == op) goto PRED_##op
+#define PREDICT(op)             if (*next_instr == op) goto PRED_##op
 #endif
 
-#define PREDICTED(op)		PRED_##op: next_instr++
-#define PREDICTED_WITH_ARG(op)	PRED_##op: oparg = PEEKARG(); next_instr += 3
+#define PREDICTED(op)           PRED_##op: next_instr++
+#define PREDICTED_WITH_ARG(op)  PRED_##op: oparg = PEEKARG(); next_instr += 3
 
 /* Stack manipulation macros */
 
 /* The stack can grow at most MAXINT deep, as co_nlocals and
    co_stacksize are ints. */
-#define STACK_LEVEL()	((int)(stack_pointer - f->f_valuestack))
-#define EMPTY()		(STACK_LEVEL() == 0)
-#define TOP()		(stack_pointer[-1])
-#define SECOND()	(stack_pointer[-2])
-#define THIRD() 	(stack_pointer[-3])
-#define FOURTH()	(stack_pointer[-4])
+#define STACK_LEVEL()   ((int)(stack_pointer - f->f_valuestack))
+#define EMPTY()         (STACK_LEVEL() == 0)
+#define TOP()           (stack_pointer[-1])
+#define SECOND()        (stack_pointer[-2])
+#define THIRD()         (stack_pointer[-3])
+#define FOURTH()        (stack_pointer[-4])
 #define PEEK(n)         (stack_pointer[-(n)])
-#define SET_TOP(v)	(stack_pointer[-1] = (v))
-#define SET_SECOND(v)	(stack_pointer[-2] = (v))
-#define SET_THIRD(v)	(stack_pointer[-3] = (v))
-#define SET_FOURTH(v)	(stack_pointer[-4] = (v))
+#define SET_TOP(v)      (stack_pointer[-1] = (v))
+#define SET_SECOND(v)   (stack_pointer[-2] = (v))
+#define SET_THIRD(v)    (stack_pointer[-3] = (v))
+#define SET_FOURTH(v)   (stack_pointer[-4] = (v))
 #define SET_VALUE(n, v) (stack_pointer[-(n)] = (v))
-#define BASIC_STACKADJ(n)	(stack_pointer += n)
-#define BASIC_PUSH(v)	(*stack_pointer++ = (v))
-#define BASIC_POP()	(*--stack_pointer)
+#define BASIC_STACKADJ(n)       (stack_pointer += n)
+#define BASIC_PUSH(v)   (*stack_pointer++ = (v))
+#define BASIC_POP()     (*--stack_pointer)
 
 #ifdef LLTRACE
-#define PUSH(v)		{ (void)(BASIC_PUSH(v), \
-                               lltrace && prtrace(TOP(), "push")); \
-                               assert(STACK_LEVEL() <= co->co_stacksize); }
-#define POP()		((void)(lltrace && prtrace(TOP(), "pop")), \
-			 BASIC_POP())
-#define STACKADJ(n)	{ (void)(BASIC_STACKADJ(n), \
-                               lltrace && prtrace(TOP(), "stackadj")); \
-                               assert(STACK_LEVEL() <= co->co_stacksize); }
+#define PUSH(v)         { (void)(BASIC_PUSH(v), \
+                   lltrace && prtrace(TOP(), "push")); \
+                   assert(STACK_LEVEL() <= co->co_stacksize); }
+#define POP()           ((void)(lltrace && prtrace(TOP(), "pop")), \
+             BASIC_POP())
+#define STACKADJ(n)     { (void)(BASIC_STACKADJ(n), \
+                   lltrace && prtrace(TOP(), "stackadj")); \
+                   assert(STACK_LEVEL() <= co->co_stacksize); }
 #define EXT_POP(STACK_POINTER) ((void)(lltrace && \
-				prtrace((STACK_POINTER)[-1], "ext_pop")), \
-				*--(STACK_POINTER))
+                prtrace((STACK_POINTER)[-1], "ext_pop")), \
+                *--(STACK_POINTER))
 #else
-#define PUSH(v)		BASIC_PUSH(v)
-#define POP()		BASIC_POP()
-#define STACKADJ(n)	BASIC_STACKADJ(n)
+#define PUSH(v)         BASIC_PUSH(v)
+#define POP()           BASIC_POP()
+#define STACKADJ(n)     BASIC_STACKADJ(n)
 #define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
 #endif
 
 /* Local variable macros */
 
-#define GETLOCAL(i)	(fastlocals[i])
+#define GETLOCAL(i)     (fastlocals[i])
 
 /* The SETLOCAL() macro must not DECREF the local variable in-place and
    then store the new value; it must copy the old value to a temporary
@@ -860,2150 +860,2150 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
    This is because it is possible that during the DECREF the frame is
    accessed by other code (e.g. a __del__ method or gc.collect()) and the
    variable would be pointing to already-freed memory. */
-#define SETLOCAL(i, value)	do { PyObject *tmp = GETLOCAL(i); \
-				     GETLOCAL(i) = value; \
-                                     Py_XDECREF(tmp); } while (0)
+#define SETLOCAL(i, value)      do { PyObject *tmp = GETLOCAL(i); \
+                     GETLOCAL(i) = value; \
+                     Py_XDECREF(tmp); } while (0)
 
 /* Start of code */
 
-	if (f == NULL)
-		return NULL;
-
-	/* push frame */
-	if (Py_EnterRecursiveCall(""))
-		return NULL;
-
-	tstate->frame = f;
-
-	if (tstate->use_tracing) {
-		if (tstate->c_tracefunc != NULL) {
-			/* tstate->c_tracefunc, if defined, is a
-			   function that will be called on *every* entry
-			   to a code block.  Its return value, if not
-			   None, is a function that will be called at
-			   the start of each executed line of code.
-			   (Actually, the function must return itself
-			   in order to continue tracing.)  The trace
-			   functions are called with three arguments:
-			   a pointer to the current frame, a string
-			   indicating why the function is called, and
-			   an argument which depends on the situation.
-			   The global trace function is also called
-			   whenever an exception is detected. */
-			if (call_trace_protected(tstate->c_tracefunc,
-						 tstate->c_traceobj,
-						 f, PyTrace_CALL, Py_None)) {
-				/* Trace function raised an error */
-				goto exit_eval_frame;
-			}
-		}
-		if (tstate->c_profilefunc != NULL) {
-			/* Similar for c_profilefunc, except it needn't
-			   return itself and isn't called for "line" events */
-			if (call_trace_protected(tstate->c_profilefunc,
-						 tstate->c_profileobj,
-						 f, PyTrace_CALL, Py_None)) {
-				/* Profile function raised an error */
-				goto exit_eval_frame;
-			}
-		}
-	}
-
-	co = f->f_code;
-	names = co->co_names;
-	consts = co->co_consts;
-	fastlocals = f->f_localsplus;
-	freevars = f->f_localsplus + co->co_nlocals;
-	first_instr = (unsigned char*) PyString_AS_STRING(co->co_code);
-	/* An explanation is in order for the next line.
-
-	   f->f_lasti now refers to the index of the last instruction
-	   executed.  You might think this was obvious from the name, but
-	   this wasn't always true before 2.3!  PyFrame_New now sets
-	   f->f_lasti to -1 (i.e. the index *before* the first instruction)
-	   and YIELD_VALUE doesn't fiddle with f_lasti any more.  So this
-	   does work.  Promise.
-
-	   When the PREDICT() macros are enabled, some opcode pairs follow in
-           direct succession without updating f->f_lasti.  A successful
-           prediction effectively links the two codes together as if they
-           were a single new opcode; accordingly,f->f_lasti will point to
-           the first code in the pair (for instance, GET_ITER followed by
-           FOR_ITER is effectively a single opcode and f->f_lasti will point
-           at to the beginning of the combined pair.)
-	*/
-	next_instr = first_instr + f->f_lasti + 1;
-	stack_pointer = f->f_stacktop;
-	assert(stack_pointer != NULL);
-	f->f_stacktop = NULL;	/* remains NULL unless yield suspends frame */
+    if (f == NULL)
+        return NULL;
+
+    /* push frame */
+    if (Py_EnterRecursiveCall(""))
+        return NULL;
+
+    tstate->frame = f;
+
+    if (tstate->use_tracing) {
+        if (tstate->c_tracefunc != NULL) {
+            /* tstate->c_tracefunc, if defined, is a
+               function that will be called on *every* entry
+               to a code block.  Its return value, if not
+               None, is a function that will be called at
+               the start of each executed line of code.
+               (Actually, the function must return itself
+               in order to continue tracing.)  The trace
+               functions are called with three arguments:
+               a pointer to the current frame, a string
+               indicating why the function is called, and
+               an argument which depends on the situation.
+               The global trace function is also called
+               whenever an exception is detected. */
+            if (call_trace_protected(tstate->c_tracefunc,
+                                     tstate->c_traceobj,
+                                     f, PyTrace_CALL, Py_None)) {
+                /* Trace function raised an error */
+                goto exit_eval_frame;
+            }
+        }
+        if (tstate->c_profilefunc != NULL) {
+            /* Similar for c_profilefunc, except it needn't
+               return itself and isn't called for "line" events */
+            if (call_trace_protected(tstate->c_profilefunc,
+                                     tstate->c_profileobj,
+                                     f, PyTrace_CALL, Py_None)) {
+                /* Profile function raised an error */
+                goto exit_eval_frame;
+            }
+        }
+    }
+
+    co = f->f_code;
+    names = co->co_names;
+    consts = co->co_consts;
+    fastlocals = f->f_localsplus;
+    freevars = f->f_localsplus + co->co_nlocals;
+    first_instr = (unsigned char*) PyString_AS_STRING(co->co_code);
+    /* An explanation is in order for the next line.
+
+       f->f_lasti now refers to the index of the last instruction
+       executed.  You might think this was obvious from the name, but
+       this wasn't always true before 2.3!  PyFrame_New now sets
+       f->f_lasti to -1 (i.e. the index *before* the first instruction)
+       and YIELD_VALUE doesn't fiddle with f_lasti any more.  So this
+       does work.  Promise.
+
+       When the PREDICT() macros are enabled, some opcode pairs follow in
+       direct succession without updating f->f_lasti.  A successful
+       prediction effectively links the two codes together as if they
+       were a single new opcode; accordingly,f->f_lasti will point to
+       the first code in the pair (for instance, GET_ITER followed by
+       FOR_ITER is effectively a single opcode and f->f_lasti will point
+       at to the beginning of the combined pair.)
+    */
+    next_instr = first_instr + f->f_lasti + 1;
+    stack_pointer = f->f_stacktop;
+    assert(stack_pointer != NULL);
+    f->f_stacktop = NULL;       /* remains NULL unless yield suspends frame */
 
 #ifdef LLTRACE
-	lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL;
+    lltrace = PyDict_GetItemString(f->f_globals, "__lltrace__") != NULL;
 #endif
 #if defined(Py_DEBUG) || defined(LLTRACE)
-	filename = PyString_AsString(co->co_filename);
+    filename = PyString_AsString(co->co_filename);
 #endif
 
-	why = WHY_NOT;
-	err = 0;
-	x = Py_None;	/* Not a reference, just anything non-NULL */
-	w = NULL;
+    why = WHY_NOT;
+    err = 0;
+    x = Py_None;        /* Not a reference, just anything non-NULL */
+    w = NULL;
 
-	if (throwflag) { /* support for generator.throw() */
-		why = WHY_EXCEPTION;
-		goto on_error;
-	}
+    if (throwflag) { /* support for generator.throw() */
+        why = WHY_EXCEPTION;
+        goto on_error;
+    }
 
-	for (;;) {
+    for (;;) {
 #ifdef WITH_TSC
-		if (inst1 == 0) {
-			/* Almost surely, the opcode executed a break
-			   or a continue, preventing inst1 from being set
-			   on the way out of the loop.
-			*/
-			READ_TIMESTAMP(inst1);
-			loop1 = inst1;
-		}
-		dump_tsc(opcode, ticked, inst0, inst1, loop0, loop1,
-			 intr0, intr1);
-		ticked = 0;
-		inst1 = 0;
-		intr0 = 0;
-		intr1 = 0;
-		READ_TIMESTAMP(loop0);
+        if (inst1 == 0) {
+            /* Almost surely, the opcode executed a break
+               or a continue, preventing inst1 from being set
+               on the way out of the loop.
+            */
+            READ_TIMESTAMP(inst1);
+            loop1 = inst1;
+        }
+        dump_tsc(opcode, ticked, inst0, inst1, loop0, loop1,
+                 intr0, intr1);
+        ticked = 0;
+        inst1 = 0;
+        intr0 = 0;
+        intr1 = 0;
+        READ_TIMESTAMP(loop0);
 #endif
-		assert(stack_pointer >= f->f_valuestack); /* else underflow */
-		assert(STACK_LEVEL() <= co->co_stacksize);  /* else overflow */
-
-		/* Do periodic things.  Doing this every time through
-		   the loop would add too much overhead, so we do it
-		   only every Nth instruction.  We also do it if
-		   ``pendingcalls_to_do'' is set, i.e. when an asynchronous
-		   event needs attention (e.g. a signal handler or
-		   async I/O handler); see Py_AddPendingCall() and
-		   Py_MakePendingCalls() above. */
-
-		if (--_Py_Ticker < 0) {
-			if (*next_instr == SETUP_FINALLY) {
-				/* Make the last opcode before
-				   a try: finally: block uninterruptable. */
-				goto fast_next_opcode;
-			}
-			_Py_Ticker = _Py_CheckInterval;
-			tstate->tick_counter++;
+        assert(stack_pointer >= f->f_valuestack); /* else underflow */
+        assert(STACK_LEVEL() <= co->co_stacksize);  /* else overflow */
+
+        /* Do periodic things.  Doing this every time through
+           the loop would add too much overhead, so we do it
+           only every Nth instruction.  We also do it if
+           ``pendingcalls_to_do'' is set, i.e. when an asynchronous
+           event needs attention (e.g. a signal handler or
+           async I/O handler); see Py_AddPendingCall() and
+           Py_MakePendingCalls() above. */
+
+        if (--_Py_Ticker < 0) {
+            if (*next_instr == SETUP_FINALLY) {
+                /* Make the last opcode before
+                   a try: finally: block uninterruptable. */
+                goto fast_next_opcode;
+            }
+            _Py_Ticker = _Py_CheckInterval;
+            tstate->tick_counter++;
 #ifdef WITH_TSC
-			ticked = 1;
+            ticked = 1;
 #endif
-			if (pendingcalls_to_do) {
-				if (Py_MakePendingCalls() < 0) {
-					why = WHY_EXCEPTION;
-					goto on_error;
-				}
-				if (pendingcalls_to_do)
-					/* MakePendingCalls() didn't succeed.
-					   Force early re-execution of this
-					   "periodic" code, possibly after
-					   a thread switch */
-					_Py_Ticker = 0;
-			}
+            if (pendingcalls_to_do) {
+                if (Py_MakePendingCalls() < 0) {
+                    why = WHY_EXCEPTION;
+                    goto on_error;
+                }
+                if (pendingcalls_to_do)
+                    /* MakePendingCalls() didn't succeed.
+                       Force early re-execution of this
+                       "periodic" code, possibly after
+                       a thread switch */
+                    _Py_Ticker = 0;
+            }
 #ifdef WITH_THREAD
-			if (interpreter_lock) {
-				/* Give another thread a chance */
-
-				if (PyThreadState_Swap(NULL) != tstate)
-					Py_FatalError("ceval: tstate mix-up");
-				PyThread_release_lock(interpreter_lock);
-
-				/* Other threads may run now */
-
-				PyThread_acquire_lock(interpreter_lock, 1);
-				if (PyThreadState_Swap(tstate) != NULL)
-					Py_FatalError("ceval: orphan tstate");
-
-				/* Check for thread interrupts */
-
-				if (tstate->async_exc != NULL) {
-					x = tstate->async_exc;
-					tstate->async_exc = NULL;
-					PyErr_SetNone(x);
-					Py_DECREF(x);
-					why = WHY_EXCEPTION;
-					goto on_error;
-				}
-			}
+            if (interpreter_lock) {
+                /* Give another thread a chance */
+
+                if (PyThreadState_Swap(NULL) != tstate)
+                    Py_FatalError("ceval: tstate mix-up");
+                PyThread_release_lock(interpreter_lock);
+
+                /* Other threads may run now */
+
+                PyThread_acquire_lock(interpreter_lock, 1);
+                if (PyThreadState_Swap(tstate) != NULL)
+                    Py_FatalError("ceval: orphan tstate");
+
+                /* Check for thread interrupts */
+
+                if (tstate->async_exc != NULL) {
+                    x = tstate->async_exc;
+                    tstate->async_exc = NULL;
+                    PyErr_SetNone(x);
+                    Py_DECREF(x);
+                    why = WHY_EXCEPTION;
+                    goto on_error;
+                }
+            }
 #endif
-		}
-
-	fast_next_opcode:
-		f->f_lasti = INSTR_OFFSET();
-
-		/* line-by-line tracing support */
-
-		if (_Py_TracingPossible &&
-		    tstate->c_tracefunc != NULL && !tstate->tracing) {
-			/* see maybe_call_line_trace
-			   for expository comments */
-			f->f_stacktop = stack_pointer;
-
-			err = maybe_call_line_trace(tstate->c_tracefunc,
-						    tstate->c_traceobj,
-						    f, &instr_lb, &instr_ub,
-						    &instr_prev);
-			/* Reload possibly changed frame fields */
-			JUMPTO(f->f_lasti);
-			if (f->f_stacktop != NULL) {
-				stack_pointer = f->f_stacktop;
-				f->f_stacktop = NULL;
-			}
-			if (err) {
-				/* trace function raised an exception */
-				goto on_error;
-			}
-		}
-
-		/* Extract opcode and argument */
-
-		opcode = NEXTOP();
-		oparg = 0;   /* allows oparg to be stored in a register because
-			it doesn't have to be remembered across a full loop */
-		if (HAS_ARG(opcode))
-			oparg = NEXTARG();
-	  dispatch_opcode:
+        }
+
+    fast_next_opcode:
+        f->f_lasti = INSTR_OFFSET();
+
+        /* line-by-line tracing support */
+
+        if (_Py_TracingPossible &&
+            tstate->c_tracefunc != NULL && !tstate->tracing) {
+            /* see maybe_call_line_trace
+               for expository comments */
+            f->f_stacktop = stack_pointer;
+
+            err = maybe_call_line_trace(tstate->c_tracefunc,
+                                        tstate->c_traceobj,
+                                        f, &instr_lb, &instr_ub,
+                                        &instr_prev);
+            /* Reload possibly changed frame fields */
+            JUMPTO(f->f_lasti);
+            if (f->f_stacktop != NULL) {
+                stack_pointer = f->f_stacktop;
+                f->f_stacktop = NULL;
+            }
+            if (err) {
+                /* trace function raised an exception */
+                goto on_error;
+            }
+        }
+
+        /* Extract opcode and argument */
+
+        opcode = NEXTOP();
+        oparg = 0;   /* allows oparg to be stored in a register because
+            it doesn't have to be remembered across a full loop */
+        if (HAS_ARG(opcode))
+            oparg = NEXTARG();
+      dispatch_opcode:
 #ifdef DYNAMIC_EXECUTION_PROFILE
 #ifdef DXPAIRS
-		dxpairs[lastopcode][opcode]++;
-		lastopcode = opcode;
+        dxpairs[lastopcode][opcode]++;
+        lastopcode = opcode;
 #endif
-		dxp[opcode]++;
+        dxp[opcode]++;
 #endif
 
 #ifdef LLTRACE
-		/* Instruction tracing */
-
-		if (lltrace) {
-			if (HAS_ARG(opcode)) {
-				printf("%d: %d, %d\n",
-				       f->f_lasti, opcode, oparg);
-			}
-			else {
-				printf("%d: %d\n",
-				       f->f_lasti, opcode);
-			}
-		}
+        /* Instruction tracing */
+
+        if (lltrace) {
+            if (HAS_ARG(opcode)) {
+                printf("%d: %d, %d\n",
+                       f->f_lasti, opcode, oparg);
+            }
+            else {
+                printf("%d: %d\n",
+                       f->f_lasti, opcode);
+            }
+        }
 #endif
 
-		/* Main switch on opcode */
-		READ_TIMESTAMP(inst0);
-
-		switch (opcode) {
-
-		/* BEWARE!
-		   It is essential that any operation that fails sets either
-		   x to NULL, err to nonzero, or why to anything but WHY_NOT,
-		   and that no operation that succeeds does this! */
-
-		/* case STOP_CODE: this is an error! */
-
-		case NOP:
-			goto fast_next_opcode;
-
-		case LOAD_FAST:
-			x = GETLOCAL(oparg);
-			if (x != NULL) {
-				Py_INCREF(x);
-				PUSH(x);
-				goto fast_next_opcode;
-			}
-			format_exc_check_arg(PyExc_UnboundLocalError,
-				UNBOUNDLOCAL_ERROR_MSG,
-				PyTuple_GetItem(co->co_varnames, oparg));
-			break;
-
-		case LOAD_CONST:
-			x = GETITEM(consts, oparg);
-			Py_INCREF(x);
-			PUSH(x);
-			goto fast_next_opcode;
-
-		PREDICTED_WITH_ARG(STORE_FAST);
-		case STORE_FAST:
-			v = POP();
-			SETLOCAL(oparg, v);
-			goto fast_next_opcode;
-
-		case POP_TOP:
-			v = POP();
-			Py_DECREF(v);
-			goto fast_next_opcode;
-
-		case ROT_TWO:
-			v = TOP();
-			w = SECOND();
-			SET_TOP(w);
-			SET_SECOND(v);
-			goto fast_next_opcode;
-
-		case ROT_THREE:
-			v = TOP();
-			w = SECOND();
-			x = THIRD();
-			SET_TOP(w);
-			SET_SECOND(x);
-			SET_THIRD(v);
-			goto fast_next_opcode;
-
-		case ROT_FOUR:
-			u = TOP();
-			v = SECOND();
-			w = THIRD();
-			x = FOURTH();
-			SET_TOP(v);
-			SET_SECOND(w);
-			SET_THIRD(x);
-			SET_FOURTH(u);
-			goto fast_next_opcode;
-
-		case DUP_TOP:
-			v = TOP();
-			Py_INCREF(v);
-			PUSH(v);
-			goto fast_next_opcode;
-
-		case DUP_TOPX:
-			if (oparg == 2) {
-				x = TOP();
-				Py_INCREF(x);
-				w = SECOND();
-				Py_INCREF(w);
-				STACKADJ(2);
-				SET_TOP(x);
-				SET_SECOND(w);
-				goto fast_next_opcode;
-			} else if (oparg == 3) {
-				x = TOP();
-				Py_INCREF(x);
-				w = SECOND();
-				Py_INCREF(w);
-				v = THIRD();
-				Py_INCREF(v);
-				STACKADJ(3);
-				SET_TOP(x);
-				SET_SECOND(w);
-				SET_THIRD(v);
-				goto fast_next_opcode;
-			}
-			Py_FatalError("invalid argument to DUP_TOPX"
-				      " (bytecode corruption?)");
-			/* Never returns, so don't bother to set why. */
-			break;
-
-		case UNARY_POSITIVE:
-			v = TOP();
-			x = PyNumber_Positive(v);
-			Py_DECREF(v);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case UNARY_NEGATIVE:
-			v = TOP();
-			x = PyNumber_Negative(v);
-			Py_DECREF(v);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case UNARY_NOT:
-			v = TOP();
-			err = PyObject_IsTrue(v);
-			Py_DECREF(v);
-			if (err == 0) {
-				Py_INCREF(Py_True);
-				SET_TOP(Py_True);
-				continue;
-			}
-			else if (err > 0) {
-				Py_INCREF(Py_False);
-				SET_TOP(Py_False);
-				err = 0;
-				continue;
-			}
-			STACKADJ(-1);
-			break;
-
-		case UNARY_CONVERT:
-			v = TOP();
-			x = PyObject_Repr(v);
-			Py_DECREF(v);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case UNARY_INVERT:
-			v = TOP();
-			x = PyNumber_Invert(v);
-			Py_DECREF(v);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_POWER:
-			w = POP();
-			v = TOP();
-			x = PyNumber_Power(v, w, Py_None);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_MULTIPLY:
-			w = POP();
-			v = TOP();
-			x = PyNumber_Multiply(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_DIVIDE:
-			if (!_Py_QnewFlag) {
-				w = POP();
-				v = TOP();
-				x = PyNumber_Divide(v, w);
-				Py_DECREF(v);
-				Py_DECREF(w);
-				SET_TOP(x);
-				if (x != NULL) continue;
-				break;
-			}
-			/* -Qnew is in effect:	fall through to
-			   BINARY_TRUE_DIVIDE */
-		case BINARY_TRUE_DIVIDE:
-			w = POP();
-			v = TOP();
-			x = PyNumber_TrueDivide(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_FLOOR_DIVIDE:
-			w = POP();
-			v = TOP();
-			x = PyNumber_FloorDivide(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_MODULO:
-			w = POP();
-			v = TOP();
-			if (PyString_CheckExact(v))
-				x = PyString_Format(v, w);
-			else
-				x = PyNumber_Remainder(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_ADD:
-			w = POP();
-			v = TOP();
-			if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
-				/* INLINE: int + int */
-				register long a, b, i;
-				a = PyInt_AS_LONG(v);
-				b = PyInt_AS_LONG(w);
-				/* cast to avoid undefined behaviour
-				   on overflow */
-				i = (long)((unsigned long)a + b);
-				if ((i^a) < 0 && (i^b) < 0)
-					goto slow_add;
-				x = PyInt_FromLong(i);
-			}
-			else if (PyString_CheckExact(v) &&
-				 PyString_CheckExact(w)) {
-				x = string_concatenate(v, w, f, next_instr);
-				/* string_concatenate consumed the ref to v */
-				goto skip_decref_vx;
-			}
-			else {
-			  slow_add:
-				x = PyNumber_Add(v, w);
-			}
-			Py_DECREF(v);
-		  skip_decref_vx:
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_SUBTRACT:
-			w = POP();
-			v = TOP();
-			if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
-				/* INLINE: int - int */
-				register long a, b, i;
-				a = PyInt_AS_LONG(v);
-				b = PyInt_AS_LONG(w);
-				/* cast to avoid undefined behaviour
-				   on overflow */
-				i = (long)((unsigned long)a - b);
-				if ((i^a) < 0 && (i^~b) < 0)
-					goto slow_sub;
-				x = PyInt_FromLong(i);
-			}
-			else {
-			  slow_sub:
-				x = PyNumber_Subtract(v, w);
-			}
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_SUBSCR:
-			w = POP();
-			v = TOP();
-			if (PyList_CheckExact(v) && PyInt_CheckExact(w)) {
-				/* INLINE: list[int] */
-				Py_ssize_t i = PyInt_AsSsize_t(w);
-				if (i < 0)
-					i += PyList_GET_SIZE(v);
-				if (i >= 0 && i < PyList_GET_SIZE(v)) {
-					x = PyList_GET_ITEM(v, i);
-					Py_INCREF(x);
-				}
-				else
-					goto slow_get;
-			}
-			else
-			  slow_get:
-				x = PyObject_GetItem(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_LSHIFT:
-			w = POP();
-			v = TOP();
-			x = PyNumber_Lshift(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_RSHIFT:
-			w = POP();
-			v = TOP();
-			x = PyNumber_Rshift(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_AND:
-			w = POP();
-			v = TOP();
-			x = PyNumber_And(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_XOR:
-			w = POP();
-			v = TOP();
-			x = PyNumber_Xor(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case BINARY_OR:
-			w = POP();
-			v = TOP();
-			x = PyNumber_Or(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case LIST_APPEND:
-			w = POP();
-			v = PEEK(oparg);
-			err = PyList_Append(v, w);
-			Py_DECREF(w);
-			if (err == 0) {
-				PREDICT(JUMP_ABSOLUTE);
-				continue;
-			}
-			break;
-
-		case SET_ADD:
-			w = POP();
-			v = stack_pointer[-oparg];
-			err = PySet_Add(v, w);
-			Py_DECREF(w);
-			if (err == 0) {
-				PREDICT(JUMP_ABSOLUTE);
-				continue;
-			}
-			break;
-
-		case INPLACE_POWER:
-			w = POP();
-			v = TOP();
-			x = PyNumber_InPlacePower(v, w, Py_None);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case INPLACE_MULTIPLY:
-			w = POP();
-			v = TOP();
-			x = PyNumber_InPlaceMultiply(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case INPLACE_DIVIDE:
-			if (!_Py_QnewFlag) {
-				w = POP();
-				v = TOP();
-				x = PyNumber_InPlaceDivide(v, w);
-				Py_DECREF(v);
-				Py_DECREF(w);
-				SET_TOP(x);
-				if (x != NULL) continue;
-				break;
-			}
-			/* -Qnew is in effect:	fall through to
-			   INPLACE_TRUE_DIVIDE */
-		case INPLACE_TRUE_DIVIDE:
-			w = POP();
-			v = TOP();
-			x = PyNumber_InPlaceTrueDivide(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case INPLACE_FLOOR_DIVIDE:
-			w = POP();
-			v = TOP();
-			x = PyNumber_InPlaceFloorDivide(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case INPLACE_MODULO:
-			w = POP();
-			v = TOP();
-			x = PyNumber_InPlaceRemainder(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case INPLACE_ADD:
-			w = POP();
-			v = TOP();
-			if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
-				/* INLINE: int + int */
-				register long a, b, i;
-				a = PyInt_AS_LONG(v);
-				b = PyInt_AS_LONG(w);
-				i = a + b;
-				if ((i^a) < 0 && (i^b) < 0)
-					goto slow_iadd;
-				x = PyInt_FromLong(i);
-			}
-			else if (PyString_CheckExact(v) &&
-				 PyString_CheckExact(w)) {
-				x = string_concatenate(v, w, f, next_instr);
-				/* string_concatenate consumed the ref to v */
-				goto skip_decref_v;
-			}
-			else {
-			  slow_iadd:
-				x = PyNumber_InPlaceAdd(v, w);
-			}
-			Py_DECREF(v);
-		  skip_decref_v:
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case INPLACE_SUBTRACT:
-			w = POP();
-			v = TOP();
-			if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
-				/* INLINE: int - int */
-				register long a, b, i;
-				a = PyInt_AS_LONG(v);
-				b = PyInt_AS_LONG(w);
-				i = a - b;
-				if ((i^a) < 0 && (i^~b) < 0)
-					goto slow_isub;
-				x = PyInt_FromLong(i);
-			}
-			else {
-			  slow_isub:
-				x = PyNumber_InPlaceSubtract(v, w);
-			}
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case INPLACE_LSHIFT:
-			w = POP();
-			v = TOP();
-			x = PyNumber_InPlaceLshift(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case INPLACE_RSHIFT:
-			w = POP();
-			v = TOP();
-			x = PyNumber_InPlaceRshift(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case INPLACE_AND:
-			w = POP();
-			v = TOP();
-			x = PyNumber_InPlaceAnd(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case INPLACE_XOR:
-			w = POP();
-			v = TOP();
-			x = PyNumber_InPlaceXor(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case INPLACE_OR:
-			w = POP();
-			v = TOP();
-			x = PyNumber_InPlaceOr(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case SLICE+0:
-		case SLICE+1:
-		case SLICE+2:
-		case SLICE+3:
-			if ((opcode-SLICE) & 2)
-				w = POP();
-			else
-				w = NULL;
-			if ((opcode-SLICE) & 1)
-				v = POP();
-			else
-				v = NULL;
-			u = TOP();
-			x = apply_slice(u, v, w);
-			Py_DECREF(u);
-			Py_XDECREF(v);
-			Py_XDECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case STORE_SLICE+0:
-		case STORE_SLICE+1:
-		case STORE_SLICE+2:
-		case STORE_SLICE+3:
-			if ((opcode-STORE_SLICE) & 2)
-				w = POP();
-			else
-				w = NULL;
-			if ((opcode-STORE_SLICE) & 1)
-				v = POP();
-			else
-				v = NULL;
-			u = POP();
-			t = POP();
-			err = assign_slice(u, v, w, t); /* u[v:w] = t */
-			Py_DECREF(t);
-			Py_DECREF(u);
-			Py_XDECREF(v);
-			Py_XDECREF(w);
-			if (err == 0) continue;
-			break;
-
-		case DELETE_SLICE+0:
-		case DELETE_SLICE+1:
-		case DELETE_SLICE+2:
-		case DELETE_SLICE+3:
-			if ((opcode-DELETE_SLICE) & 2)
-				w = POP();
-			else
-				w = NULL;
-			if ((opcode-DELETE_SLICE) & 1)
-				v = POP();
-			else
-				v = NULL;
-			u = POP();
-			err = assign_slice(u, v, w, (PyObject *)NULL);
-							/* del u[v:w] */
-			Py_DECREF(u);
-			Py_XDECREF(v);
-			Py_XDECREF(w);
-			if (err == 0) continue;
-			break;
-
-		case STORE_SUBSCR:
-			w = TOP();
-			v = SECOND();
-			u = THIRD();
-			STACKADJ(-3);
-			/* v[w] = u */
-			err = PyObject_SetItem(v, w, u);
-			Py_DECREF(u);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			if (err == 0) continue;
-			break;
-
-		case DELETE_SUBSCR:
-			w = TOP();
-			v = SECOND();
-			STACKADJ(-2);
-			/* del v[w] */
-			err = PyObject_DelItem(v, w);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			if (err == 0) continue;
-			break;
-
-		case PRINT_EXPR:
-			v = POP();
-			w = PySys_GetObject("displayhook");
-			if (w == NULL) {
-				PyErr_SetString(PyExc_RuntimeError,
-						"lost sys.displayhook");
-				err = -1;
-				x = NULL;
-			}
-			if (err == 0) {
-				x = PyTuple_Pack(1, v);
-				if (x == NULL)
-					err = -1;
-			}
-			if (err == 0) {
-				w = PyEval_CallObject(w, x);
-				Py_XDECREF(w);
-				if (w == NULL)
-					err = -1;
-			}
-			Py_DECREF(v);
-			Py_XDECREF(x);
-			break;
-
-		case PRINT_ITEM_TO:
-			w = stream = POP();
-			/* fall through to PRINT_ITEM */
-
-		case PRINT_ITEM:
-			v = POP();
-			if (stream == NULL || stream == Py_None) {
-				w = PySys_GetObject("stdout");
-				if (w == NULL) {
-					PyErr_SetString(PyExc_RuntimeError,
-							"lost sys.stdout");
-					err = -1;
-				}
-			}
-			/* PyFile_SoftSpace() can exececute arbitrary code
-			   if sys.stdout is an instance with a __getattr__.
-			   If __getattr__ raises an exception, w will
-			   be freed, so we need to prevent that temporarily. */
-			Py_XINCREF(w);
-			if (w != NULL && PyFile_SoftSpace(w, 0))
-				err = PyFile_WriteString(" ", w);
-			if (err == 0)
-				err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
-			if (err == 0) {
-			    /* XXX move into writeobject() ? */
-			    if (PyString_Check(v)) {
-				char *s = PyString_AS_STRING(v);
-				Py_ssize_t len = PyString_GET_SIZE(v);
-				if (len == 0 ||
-				    !isspace(Py_CHARMASK(s[len-1])) ||
-				    s[len-1] == ' ')
-					PyFile_SoftSpace(w, 1);
-			    }
+        /* Main switch on opcode */
+        READ_TIMESTAMP(inst0);
+
+        switch (opcode) {
+
+        /* BEWARE!
+           It is essential that any operation that fails sets either
+           x to NULL, err to nonzero, or why to anything but WHY_NOT,
+           and that no operation that succeeds does this! */
+
+        /* case STOP_CODE: this is an error! */
+
+        case NOP:
+            goto fast_next_opcode;
+
+        case LOAD_FAST:
+            x = GETLOCAL(oparg);
+            if (x != NULL) {
+                Py_INCREF(x);
+                PUSH(x);
+                goto fast_next_opcode;
+            }
+            format_exc_check_arg(PyExc_UnboundLocalError,
+                UNBOUNDLOCAL_ERROR_MSG,
+                PyTuple_GetItem(co->co_varnames, oparg));
+            break;
+
+        case LOAD_CONST:
+            x = GETITEM(consts, oparg);
+            Py_INCREF(x);
+            PUSH(x);
+            goto fast_next_opcode;
+
+        PREDICTED_WITH_ARG(STORE_FAST);
+        case STORE_FAST:
+            v = POP();
+            SETLOCAL(oparg, v);
+            goto fast_next_opcode;
+
+        case POP_TOP:
+            v = POP();
+            Py_DECREF(v);
+            goto fast_next_opcode;
+
+        case ROT_TWO:
+            v = TOP();
+            w = SECOND();
+            SET_TOP(w);
+            SET_SECOND(v);
+            goto fast_next_opcode;
+
+        case ROT_THREE:
+            v = TOP();
+            w = SECOND();
+            x = THIRD();
+            SET_TOP(w);
+            SET_SECOND(x);
+            SET_THIRD(v);
+            goto fast_next_opcode;
+
+        case ROT_FOUR:
+            u = TOP();
+            v = SECOND();
+            w = THIRD();
+            x = FOURTH();
+            SET_TOP(v);
+            SET_SECOND(w);
+            SET_THIRD(x);
+            SET_FOURTH(u);
+            goto fast_next_opcode;
+
+        case DUP_TOP:
+            v = TOP();
+            Py_INCREF(v);
+            PUSH(v);
+            goto fast_next_opcode;
+
+        case DUP_TOPX:
+            if (oparg == 2) {
+                x = TOP();
+                Py_INCREF(x);
+                w = SECOND();
+                Py_INCREF(w);
+                STACKADJ(2);
+                SET_TOP(x);
+                SET_SECOND(w);
+                goto fast_next_opcode;
+            } else if (oparg == 3) {
+                x = TOP();
+                Py_INCREF(x);
+                w = SECOND();
+                Py_INCREF(w);
+                v = THIRD();
+                Py_INCREF(v);
+                STACKADJ(3);
+                SET_TOP(x);
+                SET_SECOND(w);
+                SET_THIRD(v);
+                goto fast_next_opcode;
+            }
+            Py_FatalError("invalid argument to DUP_TOPX"
+                          " (bytecode corruption?)");
+            /* Never returns, so don't bother to set why. */
+            break;
+
+        case UNARY_POSITIVE:
+            v = TOP();
+            x = PyNumber_Positive(v);
+            Py_DECREF(v);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case UNARY_NEGATIVE:
+            v = TOP();
+            x = PyNumber_Negative(v);
+            Py_DECREF(v);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case UNARY_NOT:
+            v = TOP();
+            err = PyObject_IsTrue(v);
+            Py_DECREF(v);
+            if (err == 0) {
+                Py_INCREF(Py_True);
+                SET_TOP(Py_True);
+                continue;
+            }
+            else if (err > 0) {
+                Py_INCREF(Py_False);
+                SET_TOP(Py_False);
+                err = 0;
+                continue;
+            }
+            STACKADJ(-1);
+            break;
+
+        case UNARY_CONVERT:
+            v = TOP();
+            x = PyObject_Repr(v);
+            Py_DECREF(v);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case UNARY_INVERT:
+            v = TOP();
+            x = PyNumber_Invert(v);
+            Py_DECREF(v);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_POWER:
+            w = POP();
+            v = TOP();
+            x = PyNumber_Power(v, w, Py_None);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_MULTIPLY:
+            w = POP();
+            v = TOP();
+            x = PyNumber_Multiply(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_DIVIDE:
+            if (!_Py_QnewFlag) {
+                w = POP();
+                v = TOP();
+                x = PyNumber_Divide(v, w);
+                Py_DECREF(v);
+                Py_DECREF(w);
+                SET_TOP(x);
+                if (x != NULL) continue;
+                break;
+            }
+            /* -Qnew is in effect:              fall through to
+               BINARY_TRUE_DIVIDE */
+        case BINARY_TRUE_DIVIDE:
+            w = POP();
+            v = TOP();
+            x = PyNumber_TrueDivide(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_FLOOR_DIVIDE:
+            w = POP();
+            v = TOP();
+            x = PyNumber_FloorDivide(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_MODULO:
+            w = POP();
+            v = TOP();
+            if (PyString_CheckExact(v))
+                x = PyString_Format(v, w);
+            else
+                x = PyNumber_Remainder(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_ADD:
+            w = POP();
+            v = TOP();
+            if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
+                /* INLINE: int + int */
+                register long a, b, i;
+                a = PyInt_AS_LONG(v);
+                b = PyInt_AS_LONG(w);
+                /* cast to avoid undefined behaviour
+                   on overflow */
+                i = (long)((unsigned long)a + b);
+                if ((i^a) < 0 && (i^b) < 0)
+                    goto slow_add;
+                x = PyInt_FromLong(i);
+            }
+            else if (PyString_CheckExact(v) &&
+                     PyString_CheckExact(w)) {
+                x = string_concatenate(v, w, f, next_instr);
+                /* string_concatenate consumed the ref to v */
+                goto skip_decref_vx;
+            }
+            else {
+              slow_add:
+                x = PyNumber_Add(v, w);
+            }
+            Py_DECREF(v);
+          skip_decref_vx:
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_SUBTRACT:
+            w = POP();
+            v = TOP();
+            if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
+                /* INLINE: int - int */
+                register long a, b, i;
+                a = PyInt_AS_LONG(v);
+                b = PyInt_AS_LONG(w);
+                /* cast to avoid undefined behaviour
+                   on overflow */
+                i = (long)((unsigned long)a - b);
+                if ((i^a) < 0 && (i^~b) < 0)
+                    goto slow_sub;
+                x = PyInt_FromLong(i);
+            }
+            else {
+              slow_sub:
+                x = PyNumber_Subtract(v, w);
+            }
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_SUBSCR:
+            w = POP();
+            v = TOP();
+            if (PyList_CheckExact(v) && PyInt_CheckExact(w)) {
+                /* INLINE: list[int] */
+                Py_ssize_t i = PyInt_AsSsize_t(w);
+                if (i < 0)
+                    i += PyList_GET_SIZE(v);
+                if (i >= 0 && i < PyList_GET_SIZE(v)) {
+                    x = PyList_GET_ITEM(v, i);
+                    Py_INCREF(x);
+                }
+                else
+                    goto slow_get;
+            }
+            else
+              slow_get:
+                x = PyObject_GetItem(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_LSHIFT:
+            w = POP();
+            v = TOP();
+            x = PyNumber_Lshift(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_RSHIFT:
+            w = POP();
+            v = TOP();
+            x = PyNumber_Rshift(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_AND:
+            w = POP();
+            v = TOP();
+            x = PyNumber_And(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_XOR:
+            w = POP();
+            v = TOP();
+            x = PyNumber_Xor(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case BINARY_OR:
+            w = POP();
+            v = TOP();
+            x = PyNumber_Or(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case LIST_APPEND:
+            w = POP();
+            v = PEEK(oparg);
+            err = PyList_Append(v, w);
+            Py_DECREF(w);
+            if (err == 0) {
+                PREDICT(JUMP_ABSOLUTE);
+                continue;
+            }
+            break;
+
+        case SET_ADD:
+            w = POP();
+            v = stack_pointer[-oparg];
+            err = PySet_Add(v, w);
+            Py_DECREF(w);
+            if (err == 0) {
+                PREDICT(JUMP_ABSOLUTE);
+                continue;
+            }
+            break;
+
+        case INPLACE_POWER:
+            w = POP();
+            v = TOP();
+            x = PyNumber_InPlacePower(v, w, Py_None);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case INPLACE_MULTIPLY:
+            w = POP();
+            v = TOP();
+            x = PyNumber_InPlaceMultiply(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case INPLACE_DIVIDE:
+            if (!_Py_QnewFlag) {
+                w = POP();
+                v = TOP();
+                x = PyNumber_InPlaceDivide(v, w);
+                Py_DECREF(v);
+                Py_DECREF(w);
+                SET_TOP(x);
+                if (x != NULL) continue;
+                break;
+            }
+            /* -Qnew is in effect:              fall through to
+               INPLACE_TRUE_DIVIDE */
+        case INPLACE_TRUE_DIVIDE:
+            w = POP();
+            v = TOP();
+            x = PyNumber_InPlaceTrueDivide(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case INPLACE_FLOOR_DIVIDE:
+            w = POP();
+            v = TOP();
+            x = PyNumber_InPlaceFloorDivide(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case INPLACE_MODULO:
+            w = POP();
+            v = TOP();
+            x = PyNumber_InPlaceRemainder(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case INPLACE_ADD:
+            w = POP();
+            v = TOP();
+            if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
+                /* INLINE: int + int */
+                register long a, b, i;
+                a = PyInt_AS_LONG(v);
+                b = PyInt_AS_LONG(w);
+                i = a + b;
+                if ((i^a) < 0 && (i^b) < 0)
+                    goto slow_iadd;
+                x = PyInt_FromLong(i);
+            }
+            else if (PyString_CheckExact(v) &&
+                     PyString_CheckExact(w)) {
+                x = string_concatenate(v, w, f, next_instr);
+                /* string_concatenate consumed the ref to v */
+                goto skip_decref_v;
+            }
+            else {
+              slow_iadd:
+                x = PyNumber_InPlaceAdd(v, w);
+            }
+            Py_DECREF(v);
+          skip_decref_v:
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case INPLACE_SUBTRACT:
+            w = POP();
+            v = TOP();
+            if (PyInt_CheckExact(v) && PyInt_CheckExact(w)) {
+                /* INLINE: int - int */
+                register long a, b, i;
+                a = PyInt_AS_LONG(v);
+                b = PyInt_AS_LONG(w);
+                i = a - b;
+                if ((i^a) < 0 && (i^~b) < 0)
+                    goto slow_isub;
+                x = PyInt_FromLong(i);
+            }
+            else {
+              slow_isub:
+                x = PyNumber_InPlaceSubtract(v, w);
+            }
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case INPLACE_LSHIFT:
+            w = POP();
+            v = TOP();
+            x = PyNumber_InPlaceLshift(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case INPLACE_RSHIFT:
+            w = POP();
+            v = TOP();
+            x = PyNumber_InPlaceRshift(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case INPLACE_AND:
+            w = POP();
+            v = TOP();
+            x = PyNumber_InPlaceAnd(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case INPLACE_XOR:
+            w = POP();
+            v = TOP();
+            x = PyNumber_InPlaceXor(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case INPLACE_OR:
+            w = POP();
+            v = TOP();
+            x = PyNumber_InPlaceOr(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case SLICE+0:
+        case SLICE+1:
+        case SLICE+2:
+        case SLICE+3:
+            if ((opcode-SLICE) & 2)
+                w = POP();
+            else
+                w = NULL;
+            if ((opcode-SLICE) & 1)
+                v = POP();
+            else
+                v = NULL;
+            u = TOP();
+            x = apply_slice(u, v, w);
+            Py_DECREF(u);
+            Py_XDECREF(v);
+            Py_XDECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case STORE_SLICE+0:
+        case STORE_SLICE+1:
+        case STORE_SLICE+2:
+        case STORE_SLICE+3:
+            if ((opcode-STORE_SLICE) & 2)
+                w = POP();
+            else
+                w = NULL;
+            if ((opcode-STORE_SLICE) & 1)
+                v = POP();
+            else
+                v = NULL;
+            u = POP();
+            t = POP();
+            err = assign_slice(u, v, w, t); /* u[v:w] = t */
+            Py_DECREF(t);
+            Py_DECREF(u);
+            Py_XDECREF(v);
+            Py_XDECREF(w);
+            if (err == 0) continue;
+            break;
+
+        case DELETE_SLICE+0:
+        case DELETE_SLICE+1:
+        case DELETE_SLICE+2:
+        case DELETE_SLICE+3:
+            if ((opcode-DELETE_SLICE) & 2)
+                w = POP();
+            else
+                w = NULL;
+            if ((opcode-DELETE_SLICE) & 1)
+                v = POP();
+            else
+                v = NULL;
+            u = POP();
+            err = assign_slice(u, v, w, (PyObject *)NULL);
+                                            /* del u[v:w] */
+            Py_DECREF(u);
+            Py_XDECREF(v);
+            Py_XDECREF(w);
+            if (err == 0) continue;
+            break;
+
+        case STORE_SUBSCR:
+            w = TOP();
+            v = SECOND();
+            u = THIRD();
+            STACKADJ(-3);
+            /* v[w] = u */
+            err = PyObject_SetItem(v, w, u);
+            Py_DECREF(u);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            if (err == 0) continue;
+            break;
+
+        case DELETE_SUBSCR:
+            w = TOP();
+            v = SECOND();
+            STACKADJ(-2);
+            /* del v[w] */
+            err = PyObject_DelItem(v, w);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            if (err == 0) continue;
+            break;
+
+        case PRINT_EXPR:
+            v = POP();
+            w = PySys_GetObject("displayhook");
+            if (w == NULL) {
+                PyErr_SetString(PyExc_RuntimeError,
+                                "lost sys.displayhook");
+                err = -1;
+                x = NULL;
+            }
+            if (err == 0) {
+                x = PyTuple_Pack(1, v);
+                if (x == NULL)
+                    err = -1;
+            }
+            if (err == 0) {
+                w = PyEval_CallObject(w, x);
+                Py_XDECREF(w);
+                if (w == NULL)
+                    err = -1;
+            }
+            Py_DECREF(v);
+            Py_XDECREF(x);
+            break;
+
+        case PRINT_ITEM_TO:
+            w = stream = POP();
+            /* fall through to PRINT_ITEM */
+
+        case PRINT_ITEM:
+            v = POP();
+            if (stream == NULL || stream == Py_None) {
+                w = PySys_GetObject("stdout");
+                if (w == NULL) {
+                    PyErr_SetString(PyExc_RuntimeError,
+                                    "lost sys.stdout");
+                    err = -1;
+                }
+            }
+            /* PyFile_SoftSpace() can exececute arbitrary code
+               if sys.stdout is an instance with a __getattr__.
+               If __getattr__ raises an exception, w will
+               be freed, so we need to prevent that temporarily. */
+            Py_XINCREF(w);
+            if (w != NULL && PyFile_SoftSpace(w, 0))
+                err = PyFile_WriteString(" ", w);
+            if (err == 0)
+                err = PyFile_WriteObject(v, w, Py_PRINT_RAW);
+            if (err == 0) {
+                /* XXX move into writeobject() ? */
+                if (PyString_Check(v)) {
+                char *s = PyString_AS_STRING(v);
+                Py_ssize_t len = PyString_GET_SIZE(v);
+                if (len == 0 ||
+                    !isspace(Py_CHARMASK(s[len-1])) ||
+                    s[len-1] == ' ')
+                    PyFile_SoftSpace(w, 1);
+                }
 #ifdef Py_USING_UNICODE
-			    else if (PyUnicode_Check(v)) {
-				Py_UNICODE *s = PyUnicode_AS_UNICODE(v);
-				Py_ssize_t len = PyUnicode_GET_SIZE(v);
-				if (len == 0 ||
-				    !Py_UNICODE_ISSPACE(s[len-1]) ||
-				    s[len-1] == ' ')
-				    PyFile_SoftSpace(w, 1);
-			    }
+                else if (PyUnicode_Check(v)) {
+                Py_UNICODE *s = PyUnicode_AS_UNICODE(v);
+                Py_ssize_t len = PyUnicode_GET_SIZE(v);
+                if (len == 0 ||
+                    !Py_UNICODE_ISSPACE(s[len-1]) ||
+                    s[len-1] == ' ')
+                    PyFile_SoftSpace(w, 1);
+                }
 #endif
-			    else
-			    	PyFile_SoftSpace(w, 1);
-			}
-			Py_XDECREF(w);
-			Py_DECREF(v);
-			Py_XDECREF(stream);
-			stream = NULL;
-			if (err == 0)
-				continue;
-			break;
-
-		case PRINT_NEWLINE_TO:
-			w = stream = POP();
-			/* fall through to PRINT_NEWLINE */
-
-		case PRINT_NEWLINE:
-			if (stream == NULL || stream == Py_None) {
-				w = PySys_GetObject("stdout");
-				if (w == NULL) {
-					PyErr_SetString(PyExc_RuntimeError,
-							"lost sys.stdout");
-					why = WHY_EXCEPTION;
-				}
-			}
-			if (w != NULL) {
-				/* w.write() may replace sys.stdout, so we
-				 * have to keep our reference to it */
-				Py_INCREF(w);
-				err = PyFile_WriteString("\n", w);
-				if (err == 0)
-					PyFile_SoftSpace(w, 0);
-				Py_DECREF(w);
-			}
-			Py_XDECREF(stream);
-			stream = NULL;
-			break;
+                else
+                PyFile_SoftSpace(w, 1);
+            }
+            Py_XDECREF(w);
+            Py_DECREF(v);
+            Py_XDECREF(stream);
+            stream = NULL;
+            if (err == 0)
+                continue;
+            break;
+
+        case PRINT_NEWLINE_TO:
+            w = stream = POP();
+            /* fall through to PRINT_NEWLINE */
+
+        case PRINT_NEWLINE:
+            if (stream == NULL || stream == Py_None) {
+                w = PySys_GetObject("stdout");
+                if (w == NULL) {
+                    PyErr_SetString(PyExc_RuntimeError,
+                                    "lost sys.stdout");
+                    why = WHY_EXCEPTION;
+                }
+            }
+            if (w != NULL) {
+                /* w.write() may replace sys.stdout, so we
+                 * have to keep our reference to it */
+                Py_INCREF(w);
+                err = PyFile_WriteString("\n", w);
+                if (err == 0)
+                    PyFile_SoftSpace(w, 0);
+                Py_DECREF(w);
+            }
+            Py_XDECREF(stream);
+            stream = NULL;
+            break;
 
 
 #ifdef CASE_TOO_BIG
-		default: switch (opcode) {
+        default: switch (opcode) {
 #endif
-		case RAISE_VARARGS:
-			u = v = w = NULL;
-			switch (oparg) {
-			case 3:
-				u = POP(); /* traceback */
-				/* Fallthrough */
-			case 2:
-				v = POP(); /* value */
-				/* Fallthrough */
-			case 1:
-				w = POP(); /* exc */
-			case 0: /* Fallthrough */
-				why = do_raise(w, v, u);
-				break;
-			default:
-				PyErr_SetString(PyExc_SystemError,
-					   "bad RAISE_VARARGS oparg");
-				why = WHY_EXCEPTION;
-				break;
-			}
-			break;
-
-		case LOAD_LOCALS:
-			if ((x = f->f_locals) != NULL) {
-				Py_INCREF(x);
-				PUSH(x);
-				continue;
-			}
-			PyErr_SetString(PyExc_SystemError, "no locals");
-			break;
-
-		case RETURN_VALUE:
-			retval = POP();
-			why = WHY_RETURN;
-			goto fast_block_end;
-
-		case YIELD_VALUE:
-			retval = POP();
-			f->f_stacktop = stack_pointer;
-			why = WHY_YIELD;
-			goto fast_yield;
-
-		case EXEC_STMT:
-			w = TOP();
-			v = SECOND();
-			u = THIRD();
-			STACKADJ(-3);
-			READ_TIMESTAMP(intr0);
-			err = exec_statement(f, u, v, w);
-			READ_TIMESTAMP(intr1);
-			Py_DECREF(u);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			break;
-
-		case POP_BLOCK:
-			{
-				PyTryBlock *b = PyFrame_BlockPop(f);
-				while (STACK_LEVEL() > b->b_level) {
-					v = POP();
-					Py_DECREF(v);
-				}
-			}
-			continue;
-
-		PREDICTED(END_FINALLY);
-		case END_FINALLY:
-			v = POP();
-			if (PyInt_Check(v)) {
-				why = (enum why_code) PyInt_AS_LONG(v);
-				assert(why != WHY_YIELD);
-				if (why == WHY_RETURN ||
-				    why == WHY_CONTINUE)
-					retval = POP();
-			}
-			else if (PyExceptionClass_Check(v) ||
-			         PyString_Check(v)) {
-				w = POP();
-				u = POP();
-				PyErr_Restore(v, w, u);
-				why = WHY_RERAISE;
-				break;
-			}
-			else if (v != Py_None) {
-				PyErr_SetString(PyExc_SystemError,
-					"'finally' pops bad exception");
-				why = WHY_EXCEPTION;
-			}
-			Py_DECREF(v);
-			break;
-
-		case BUILD_CLASS:
-			u = TOP();
-			v = SECOND();
-			w = THIRD();
-			STACKADJ(-2);
-			x = build_class(u, v, w);
-			SET_TOP(x);
-			Py_DECREF(u);
-			Py_DECREF(v);
-			Py_DECREF(w);
-			break;
-
-		case STORE_NAME:
-			w = GETITEM(names, oparg);
-			v = POP();
-			if ((x = f->f_locals) != NULL) {
-				if (PyDict_CheckExact(x))
-					err = PyDict_SetItem(x, w, v);
-				else
-					err = PyObject_SetItem(x, w, v);
-				Py_DECREF(v);
-				if (err == 0) continue;
-				break;
-			}
-			PyErr_Format(PyExc_SystemError,
-				     "no locals found when storing %s",
-				     PyObject_REPR(w));
-			break;
-
-		case DELETE_NAME:
-			w = GETITEM(names, oparg);
-			if ((x = f->f_locals) != NULL) {
-				if ((err = PyObject_DelItem(x, w)) != 0)
-					format_exc_check_arg(PyExc_NameError,
-							     NAME_ERROR_MSG,
-							     w);
-				break;
-			}
-			PyErr_Format(PyExc_SystemError,
-				     "no locals when deleting %s",
-				     PyObject_REPR(w));
-			break;
-
-		PREDICTED_WITH_ARG(UNPACK_SEQUENCE);
-		case UNPACK_SEQUENCE:
-			v = POP();
-			if (PyTuple_CheckExact(v) &&
-			    PyTuple_GET_SIZE(v) == oparg) {
-				PyObject **items = \
-					((PyTupleObject *)v)->ob_item;
-				while (oparg--) {
-					w = items[oparg];
-					Py_INCREF(w);
-					PUSH(w);
-				}
-				Py_DECREF(v);
-				continue;
-			} else if (PyList_CheckExact(v) &&
-				   PyList_GET_SIZE(v) == oparg) {
-				PyObject **items = \
-					((PyListObject *)v)->ob_item;
-				while (oparg--) {
-					w = items[oparg];
-					Py_INCREF(w);
-					PUSH(w);
-				}
-			} else if (unpack_iterable(v, oparg,
-						   stack_pointer + oparg)) {
-				STACKADJ(oparg);
-			} else {
-				/* unpack_iterable() raised an exception */
-				why = WHY_EXCEPTION;
-			}
-			Py_DECREF(v);
-			break;
-
-		case STORE_ATTR:
-			w = GETITEM(names, oparg);
-			v = TOP();
-			u = SECOND();
-			STACKADJ(-2);
-			err = PyObject_SetAttr(v, w, u); /* v.w = u */
-			Py_DECREF(v);
-			Py_DECREF(u);
-			if (err == 0) continue;
-			break;
-
-		case DELETE_ATTR:
-			w = GETITEM(names, oparg);
-			v = POP();
-			err = PyObject_SetAttr(v, w, (PyObject *)NULL);
-							/* del v.w */
-			Py_DECREF(v);
-			break;
-
-		case STORE_GLOBAL:
-			w = GETITEM(names, oparg);
-			v = POP();
-			err = PyDict_SetItem(f->f_globals, w, v);
-			Py_DECREF(v);
-			if (err == 0) continue;
-			break;
-
-		case DELETE_GLOBAL:
-			w = GETITEM(names, oparg);
-			if ((err = PyDict_DelItem(f->f_globals, w)) != 0)
-				format_exc_check_arg(
-				    PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w);
-			break;
-
-		case LOAD_NAME:
-			w = GETITEM(names, oparg);
-			if ((v = f->f_locals) == NULL) {
-				PyErr_Format(PyExc_SystemError,
-					     "no locals when loading %s",
-					     PyObject_REPR(w));
-				why = WHY_EXCEPTION;
-				break;
-			}
-			if (PyDict_CheckExact(v)) {
-				x = PyDict_GetItem(v, w);
-				Py_XINCREF(x);
-			}
-			else {
-				x = PyObject_GetItem(v, w);
-				if (x == NULL && PyErr_Occurred()) {
-					if (!PyErr_ExceptionMatches(
-							PyExc_KeyError))
-						break;
-					PyErr_Clear();
-				}
-			}
-			if (x == NULL) {
-				x = PyDict_GetItem(f->f_globals, w);
-				if (x == NULL) {
-					x = PyDict_GetItem(f->f_builtins, w);
-					if (x == NULL) {
-						format_exc_check_arg(
-							    PyExc_NameError,
-							    NAME_ERROR_MSG, w);
-						break;
-					}
-				}
-				Py_INCREF(x);
-			}
-			PUSH(x);
-			continue;
-
-		case LOAD_GLOBAL:
-			w = GETITEM(names, oparg);
-			if (PyString_CheckExact(w)) {
-				/* Inline the PyDict_GetItem() calls.
-				   WARNING: this is an extreme speed hack.
-				   Do not try this at home. */
-				long hash = ((PyStringObject *)w)->ob_shash;
-				if (hash != -1) {
-					PyDictObject *d;
-					PyDictEntry *e;
-					d = (PyDictObject *)(f->f_globals);
-					e = d->ma_lookup(d, w, hash);
-					if (e == NULL) {
-						x = NULL;
-						break;
-					}
-					x = e->me_value;
-					if (x != NULL) {
-						Py_INCREF(x);
-						PUSH(x);
-						continue;
-					}
-					d = (PyDictObject *)(f->f_builtins);
-					e = d->ma_lookup(d, w, hash);
-					if (e == NULL) {
-						x = NULL;
-						break;
-					}
-					x = e->me_value;
-					if (x != NULL) {
-						Py_INCREF(x);
-						PUSH(x);
-						continue;
-					}
-					goto load_global_error;
-				}
-			}
-			/* This is the un-inlined version of the code above */
-			x = PyDict_GetItem(f->f_globals, w);
-			if (x == NULL) {
-				x = PyDict_GetItem(f->f_builtins, w);
-				if (x == NULL) {
-				  load_global_error:
-					format_exc_check_arg(
-						    PyExc_NameError,
-						    GLOBAL_NAME_ERROR_MSG, w);
-					break;
-				}
-			}
-			Py_INCREF(x);
-			PUSH(x);
-			continue;
-
-		case DELETE_FAST:
-			x = GETLOCAL(oparg);
-			if (x != NULL) {
-				SETLOCAL(oparg, NULL);
-				continue;
-			}
-			format_exc_check_arg(
-				PyExc_UnboundLocalError,
-				UNBOUNDLOCAL_ERROR_MSG,
-				PyTuple_GetItem(co->co_varnames, oparg)
-				);
-			break;
-
-		case LOAD_CLOSURE:
-			x = freevars[oparg];
-			Py_INCREF(x);
-			PUSH(x);
-			if (x != NULL) continue;
-			break;
-
-		case LOAD_DEREF:
-			x = freevars[oparg];
-			w = PyCell_Get(x);
-			if (w != NULL) {
-				PUSH(w);
-				continue;
-			}
-			err = -1;
-			/* Don't stomp existing exception */
-			if (PyErr_Occurred())
-				break;
-			if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) {
-				v = PyTuple_GET_ITEM(co->co_cellvars,
-						       oparg);
-			       format_exc_check_arg(
-				       PyExc_UnboundLocalError,
-				       UNBOUNDLOCAL_ERROR_MSG,
-				       v);
-			} else {
-				v = PyTuple_GET_ITEM(co->co_freevars, oparg -
-					PyTuple_GET_SIZE(co->co_cellvars));
-				format_exc_check_arg(PyExc_NameError,
-						     UNBOUNDFREE_ERROR_MSG, v);
-			}
-			break;
-
-		case STORE_DEREF:
-			w = POP();
-			x = freevars[oparg];
-			PyCell_Set(x, w);
-			Py_DECREF(w);
-			continue;
-
-		case BUILD_TUPLE:
-			x = PyTuple_New(oparg);
-			if (x != NULL) {
-				for (; --oparg >= 0;) {
-					w = POP();
-					PyTuple_SET_ITEM(x, oparg, w);
-				}
-				PUSH(x);
-				continue;
-			}
-			break;
-
-		case BUILD_LIST:
-			x =  PyList_New(oparg);
-			if (x != NULL) {
-				for (; --oparg >= 0;) {
-					w = POP();
-					PyList_SET_ITEM(x, oparg, w);
-				}
-				PUSH(x);
-				continue;
-			}
-			break;
-
-		case BUILD_SET:
-			x = PySet_New(NULL);
-			if (x != NULL) {
-				for (; --oparg >= 0;) {
-					w = POP();
-					if (err == 0)
-						err = PySet_Add(x, w);
-					Py_DECREF(w);
-				}
-				if (err != 0) {
-					Py_DECREF(x);
-					break;
-				}
-				PUSH(x);
-				continue;
-			}
-			break;
-
-
-		case BUILD_MAP:
-			x = _PyDict_NewPresized((Py_ssize_t)oparg);
-			PUSH(x);
-			if (x != NULL) continue;
-			break;
-
-		case STORE_MAP:
-			w = TOP();     /* key */
-			u = SECOND();  /* value */
-			v = THIRD();   /* dict */
-			STACKADJ(-2);
-			assert (PyDict_CheckExact(v));
-			err = PyDict_SetItem(v, w, u);  /* v[w] = u */
-			Py_DECREF(u);
-			Py_DECREF(w);
-			if (err == 0) continue;
-			break;
-
-		case MAP_ADD:
-			w = TOP();     /* key */
-			u = SECOND();  /* value */
-			STACKADJ(-2);
-			v = stack_pointer[-oparg];  /* dict */
-			assert (PyDict_CheckExact(v));
-			err = PyDict_SetItem(v, w, u);  /* v[w] = u */
-			Py_DECREF(u);
-			Py_DECREF(w);
-			if (err == 0) {
-				PREDICT(JUMP_ABSOLUTE);
-				continue;
-			}
-			break;
-
-		case LOAD_ATTR:
-			w = GETITEM(names, oparg);
-			v = TOP();
-			x = PyObject_GetAttr(v, w);
-			Py_DECREF(v);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case COMPARE_OP:
-			w = POP();
-			v = TOP();
-			if (PyInt_CheckExact(w) && PyInt_CheckExact(v)) {
-				/* INLINE: cmp(int, int) */
-				register long a, b;
-				register int res;
-				a = PyInt_AS_LONG(v);
-				b = PyInt_AS_LONG(w);
-				switch (oparg) {
-				case PyCmp_LT: res = a <  b; break;
-				case PyCmp_LE: res = a <= b; break;
-				case PyCmp_EQ: res = a == b; break;
-				case PyCmp_NE: res = a != b; break;
-				case PyCmp_GT: res = a >  b; break;
-				case PyCmp_GE: res = a >= b; break;
-				case PyCmp_IS: res = v == w; break;
-				case PyCmp_IS_NOT: res = v != w; break;
-				default: goto slow_compare;
-				}
-				x = res ? Py_True : Py_False;
-				Py_INCREF(x);
-			}
-			else {
-			  slow_compare:
-				x = cmp_outcome(oparg, v, w);
-			}
-			Py_DECREF(v);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x == NULL) break;
-			PREDICT(POP_JUMP_IF_FALSE);
-			PREDICT(POP_JUMP_IF_TRUE);
-			continue;
-
-		case IMPORT_NAME:
-			w = GETITEM(names, oparg);
-			x = PyDict_GetItemString(f->f_builtins, "__import__");
-			if (x == NULL) {
-				PyErr_SetString(PyExc_ImportError,
-						"__import__ not found");
-				break;
-			}
-			Py_INCREF(x);
-			v = POP();
-			u = TOP();
-			if (PyInt_AsLong(u) != -1 || PyErr_Occurred())
-				w = PyTuple_Pack(5,
-					    w,
-					    f->f_globals,
-					    f->f_locals == NULL ?
-						  Py_None : f->f_locals,
-					    v,
-					    u);
-			else
-				w = PyTuple_Pack(4,
-					    w,
-					    f->f_globals,
-					    f->f_locals == NULL ?
-						  Py_None : f->f_locals,
-					    v);
-			Py_DECREF(v);
-			Py_DECREF(u);
-			if (w == NULL) {
-				u = POP();
-				Py_DECREF(x);
-				x = NULL;
-				break;
-			}
-			READ_TIMESTAMP(intr0);
-			v = x;
-			x = PyEval_CallObject(v, w);
-			Py_DECREF(v);
-			READ_TIMESTAMP(intr1);
-			Py_DECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case IMPORT_STAR:
-			v = POP();
-			PyFrame_FastToLocals(f);
-			if ((x = f->f_locals) == NULL) {
-				PyErr_SetString(PyExc_SystemError,
-					"no locals found during 'import *'");
-				break;
-			}
-			READ_TIMESTAMP(intr0);
-			err = import_all_from(x, v);
-			READ_TIMESTAMP(intr1);
-			PyFrame_LocalsToFast(f, 0);
-			Py_DECREF(v);
-			if (err == 0) continue;
-			break;
-
-		case IMPORT_FROM:
-			w = GETITEM(names, oparg);
-			v = TOP();
-			READ_TIMESTAMP(intr0);
-			x = import_from(v, w);
-			READ_TIMESTAMP(intr1);
-			PUSH(x);
-			if (x != NULL) continue;
-			break;
-
-		case JUMP_FORWARD:
-			JUMPBY(oparg);
-			goto fast_next_opcode;
-
-		PREDICTED_WITH_ARG(POP_JUMP_IF_FALSE);
-		case POP_JUMP_IF_FALSE:
-			w = POP();
-			if (w == Py_True) {
-				Py_DECREF(w);
-				goto fast_next_opcode;
-			}
-			if (w == Py_False) {
-				Py_DECREF(w);
-				JUMPTO(oparg);
-				goto fast_next_opcode;
-			}
-			err = PyObject_IsTrue(w);
-			Py_DECREF(w);
-			if (err > 0)
-				err = 0;
-			else if (err == 0)
-				JUMPTO(oparg);
-			else
-				break;
-			continue;
-
-		PREDICTED_WITH_ARG(POP_JUMP_IF_TRUE);
-		case POP_JUMP_IF_TRUE:
-			w = POP();
-			if (w == Py_False) {
-				Py_DECREF(w);
-				goto fast_next_opcode;
-			}
-			if (w == Py_True) {
-				Py_DECREF(w);
-				JUMPTO(oparg);
-				goto fast_next_opcode;
-			}
-			err = PyObject_IsTrue(w);
-			Py_DECREF(w);
-			if (err > 0) {
-				err = 0;
-				JUMPTO(oparg);
-			}
-			else if (err == 0)
-				;
-			else
-				break;
-			continue;
-
-		case JUMP_IF_FALSE_OR_POP:
-			w = TOP();
-			if (w == Py_True) {
-				STACKADJ(-1);
-				Py_DECREF(w);
-				goto fast_next_opcode;
-			}
-			if (w == Py_False) {
-				JUMPTO(oparg);
-				goto fast_next_opcode;
-			}
-			err = PyObject_IsTrue(w);
-			if (err > 0) {
-				STACKADJ(-1);
-				Py_DECREF(w);
-				err = 0;
-			}
-			else if (err == 0)
-				JUMPTO(oparg);
-			else
-				break;
-			continue;
-
-		case JUMP_IF_TRUE_OR_POP:
-			w = TOP();
-			if (w == Py_False) {
-				STACKADJ(-1);
-				Py_DECREF(w);
-				goto fast_next_opcode;
-			}
-			if (w == Py_True) {
-				JUMPTO(oparg);
-				goto fast_next_opcode;
-			}
-			err = PyObject_IsTrue(w);
-			if (err > 0) {
-				err = 0;
-				JUMPTO(oparg);
-			}
-			else if (err == 0) {
-				STACKADJ(-1);
-				Py_DECREF(w);
-			}
-			else
-				break;
-			continue;
-
-		PREDICTED_WITH_ARG(JUMP_ABSOLUTE);
-		case JUMP_ABSOLUTE:
-			JUMPTO(oparg);
+        case RAISE_VARARGS:
+            u = v = w = NULL;
+            switch (oparg) {
+            case 3:
+                u = POP(); /* traceback */
+                /* Fallthrough */
+            case 2:
+                v = POP(); /* value */
+                /* Fallthrough */
+            case 1:
+                w = POP(); /* exc */
+            case 0: /* Fallthrough */
+                why = do_raise(w, v, u);
+                break;
+            default:
+                PyErr_SetString(PyExc_SystemError,
+                           "bad RAISE_VARARGS oparg");
+                why = WHY_EXCEPTION;
+                break;
+            }
+            break;
+
+        case LOAD_LOCALS:
+            if ((x = f->f_locals) != NULL) {
+                Py_INCREF(x);
+                PUSH(x);
+                continue;
+            }
+            PyErr_SetString(PyExc_SystemError, "no locals");
+            break;
+
+        case RETURN_VALUE:
+            retval = POP();
+            why = WHY_RETURN;
+            goto fast_block_end;
+
+        case YIELD_VALUE:
+            retval = POP();
+            f->f_stacktop = stack_pointer;
+            why = WHY_YIELD;
+            goto fast_yield;
+
+        case EXEC_STMT:
+            w = TOP();
+            v = SECOND();
+            u = THIRD();
+            STACKADJ(-3);
+            READ_TIMESTAMP(intr0);
+            err = exec_statement(f, u, v, w);
+            READ_TIMESTAMP(intr1);
+            Py_DECREF(u);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            break;
+
+        case POP_BLOCK:
+            {
+                PyTryBlock *b = PyFrame_BlockPop(f);
+                while (STACK_LEVEL() > b->b_level) {
+                    v = POP();
+                    Py_DECREF(v);
+                }
+            }
+            continue;
+
+        PREDICTED(END_FINALLY);
+        case END_FINALLY:
+            v = POP();
+            if (PyInt_Check(v)) {
+                why = (enum why_code) PyInt_AS_LONG(v);
+                assert(why != WHY_YIELD);
+                if (why == WHY_RETURN ||
+                    why == WHY_CONTINUE)
+                    retval = POP();
+            }
+            else if (PyExceptionClass_Check(v) ||
+                     PyString_Check(v)) {
+                w = POP();
+                u = POP();
+                PyErr_Restore(v, w, u);
+                why = WHY_RERAISE;
+                break;
+            }
+            else if (v != Py_None) {
+                PyErr_SetString(PyExc_SystemError,
+                    "'finally' pops bad exception");
+                why = WHY_EXCEPTION;
+            }
+            Py_DECREF(v);
+            break;
+
+        case BUILD_CLASS:
+            u = TOP();
+            v = SECOND();
+            w = THIRD();
+            STACKADJ(-2);
+            x = build_class(u, v, w);
+            SET_TOP(x);
+            Py_DECREF(u);
+            Py_DECREF(v);
+            Py_DECREF(w);
+            break;
+
+        case STORE_NAME:
+            w = GETITEM(names, oparg);
+            v = POP();
+            if ((x = f->f_locals) != NULL) {
+                if (PyDict_CheckExact(x))
+                    err = PyDict_SetItem(x, w, v);
+                else
+                    err = PyObject_SetItem(x, w, v);
+                Py_DECREF(v);
+                if (err == 0) continue;
+                break;
+            }
+            PyErr_Format(PyExc_SystemError,
+                         "no locals found when storing %s",
+                         PyObject_REPR(w));
+            break;
+
+        case DELETE_NAME:
+            w = GETITEM(names, oparg);
+            if ((x = f->f_locals) != NULL) {
+                if ((err = PyObject_DelItem(x, w)) != 0)
+                    format_exc_check_arg(PyExc_NameError,
+                                         NAME_ERROR_MSG,
+                                         w);
+                break;
+            }
+            PyErr_Format(PyExc_SystemError,
+                         "no locals when deleting %s",
+                         PyObject_REPR(w));
+            break;
+
+        PREDICTED_WITH_ARG(UNPACK_SEQUENCE);
+        case UNPACK_SEQUENCE:
+            v = POP();
+            if (PyTuple_CheckExact(v) &&
+                PyTuple_GET_SIZE(v) == oparg) {
+                PyObject **items = \
+                    ((PyTupleObject *)v)->ob_item;
+                while (oparg--) {
+                    w = items[oparg];
+                    Py_INCREF(w);
+                    PUSH(w);
+                }
+                Py_DECREF(v);
+                continue;
+            } else if (PyList_CheckExact(v) &&
+                       PyList_GET_SIZE(v) == oparg) {
+                PyObject **items = \
+                    ((PyListObject *)v)->ob_item;
+                while (oparg--) {
+                    w = items[oparg];
+                    Py_INCREF(w);
+                    PUSH(w);
+                }
+            } else if (unpack_iterable(v, oparg,
+                                       stack_pointer + oparg)) {
+                STACKADJ(oparg);
+            } else {
+                /* unpack_iterable() raised an exception */
+                why = WHY_EXCEPTION;
+            }
+            Py_DECREF(v);
+            break;
+
+        case STORE_ATTR:
+            w = GETITEM(names, oparg);
+            v = TOP();
+            u = SECOND();
+            STACKADJ(-2);
+            err = PyObject_SetAttr(v, w, u); /* v.w = u */
+            Py_DECREF(v);
+            Py_DECREF(u);
+            if (err == 0) continue;
+            break;
+
+        case DELETE_ATTR:
+            w = GETITEM(names, oparg);
+            v = POP();
+            err = PyObject_SetAttr(v, w, (PyObject *)NULL);
+                                            /* del v.w */
+            Py_DECREF(v);
+            break;
+
+        case STORE_GLOBAL:
+            w = GETITEM(names, oparg);
+            v = POP();
+            err = PyDict_SetItem(f->f_globals, w, v);
+            Py_DECREF(v);
+            if (err == 0) continue;
+            break;
+
+        case DELETE_GLOBAL:
+            w = GETITEM(names, oparg);
+            if ((err = PyDict_DelItem(f->f_globals, w)) != 0)
+                format_exc_check_arg(
+                    PyExc_NameError, GLOBAL_NAME_ERROR_MSG, w);
+            break;
+
+        case LOAD_NAME:
+            w = GETITEM(names, oparg);
+            if ((v = f->f_locals) == NULL) {
+                PyErr_Format(PyExc_SystemError,
+                             "no locals when loading %s",
+                             PyObject_REPR(w));
+                why = WHY_EXCEPTION;
+                break;
+            }
+            if (PyDict_CheckExact(v)) {
+                x = PyDict_GetItem(v, w);
+                Py_XINCREF(x);
+            }
+            else {
+                x = PyObject_GetItem(v, w);
+                if (x == NULL && PyErr_Occurred()) {
+                    if (!PyErr_ExceptionMatches(
+                                    PyExc_KeyError))
+                        break;
+                    PyErr_Clear();
+                }
+            }
+            if (x == NULL) {
+                x = PyDict_GetItem(f->f_globals, w);
+                if (x == NULL) {
+                    x = PyDict_GetItem(f->f_builtins, w);
+                    if (x == NULL) {
+                        format_exc_check_arg(
+                                    PyExc_NameError,
+                                    NAME_ERROR_MSG, w);
+                        break;
+                    }
+                }
+                Py_INCREF(x);
+            }
+            PUSH(x);
+            continue;
+
+        case LOAD_GLOBAL:
+            w = GETITEM(names, oparg);
+            if (PyString_CheckExact(w)) {
+                /* Inline the PyDict_GetItem() calls.
+                   WARNING: this is an extreme speed hack.
+                   Do not try this at home. */
+                long hash = ((PyStringObject *)w)->ob_shash;
+                if (hash != -1) {
+                    PyDictObject *d;
+                    PyDictEntry *e;
+                    d = (PyDictObject *)(f->f_globals);
+                    e = d->ma_lookup(d, w, hash);
+                    if (e == NULL) {
+                        x = NULL;
+                        break;
+                    }
+                    x = e->me_value;
+                    if (x != NULL) {
+                        Py_INCREF(x);
+                        PUSH(x);
+                        continue;
+                    }
+                    d = (PyDictObject *)(f->f_builtins);
+                    e = d->ma_lookup(d, w, hash);
+                    if (e == NULL) {
+                        x = NULL;
+                        break;
+                    }
+                    x = e->me_value;
+                    if (x != NULL) {
+                        Py_INCREF(x);
+                        PUSH(x);
+                        continue;
+                    }
+                    goto load_global_error;
+                }
+            }
+            /* This is the un-inlined version of the code above */
+            x = PyDict_GetItem(f->f_globals, w);
+            if (x == NULL) {
+                x = PyDict_GetItem(f->f_builtins, w);
+                if (x == NULL) {
+                  load_global_error:
+                    format_exc_check_arg(
+                                PyExc_NameError,
+                                GLOBAL_NAME_ERROR_MSG, w);
+                    break;
+                }
+            }
+            Py_INCREF(x);
+            PUSH(x);
+            continue;
+
+        case DELETE_FAST:
+            x = GETLOCAL(oparg);
+            if (x != NULL) {
+                SETLOCAL(oparg, NULL);
+                continue;
+            }
+            format_exc_check_arg(
+                PyExc_UnboundLocalError,
+                UNBOUNDLOCAL_ERROR_MSG,
+                PyTuple_GetItem(co->co_varnames, oparg)
+                );
+            break;
+
+        case LOAD_CLOSURE:
+            x = freevars[oparg];
+            Py_INCREF(x);
+            PUSH(x);
+            if (x != NULL) continue;
+            break;
+
+        case LOAD_DEREF:
+            x = freevars[oparg];
+            w = PyCell_Get(x);
+            if (w != NULL) {
+                PUSH(w);
+                continue;
+            }
+            err = -1;
+            /* Don't stomp existing exception */
+            if (PyErr_Occurred())
+                break;
+            if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) {
+                v = PyTuple_GET_ITEM(co->co_cellvars,
+                                       oparg);
+                   format_exc_check_arg(
+                       PyExc_UnboundLocalError,
+                       UNBOUNDLOCAL_ERROR_MSG,
+                       v);
+            } else {
+                v = PyTuple_GET_ITEM(co->co_freevars, oparg -
+                    PyTuple_GET_SIZE(co->co_cellvars));
+                format_exc_check_arg(PyExc_NameError,
+                                     UNBOUNDFREE_ERROR_MSG, v);
+            }
+            break;
+
+        case STORE_DEREF:
+            w = POP();
+            x = freevars[oparg];
+            PyCell_Set(x, w);
+            Py_DECREF(w);
+            continue;
+
+        case BUILD_TUPLE:
+            x = PyTuple_New(oparg);
+            if (x != NULL) {
+                for (; --oparg >= 0;) {
+                    w = POP();
+                    PyTuple_SET_ITEM(x, oparg, w);
+                }
+                PUSH(x);
+                continue;
+            }
+            break;
+
+        case BUILD_LIST:
+            x =  PyList_New(oparg);
+            if (x != NULL) {
+                for (; --oparg >= 0;) {
+                    w = POP();
+                    PyList_SET_ITEM(x, oparg, w);
+                }
+                PUSH(x);
+                continue;
+            }
+            break;
+
+        case BUILD_SET:
+            x = PySet_New(NULL);
+            if (x != NULL) {
+                for (; --oparg >= 0;) {
+                    w = POP();
+                    if (err == 0)
+                        err = PySet_Add(x, w);
+                    Py_DECREF(w);
+                }
+                if (err != 0) {
+                    Py_DECREF(x);
+                    break;
+                }
+                PUSH(x);
+                continue;
+            }
+            break;
+
+
+        case BUILD_MAP:
+            x = _PyDict_NewPresized((Py_ssize_t)oparg);
+            PUSH(x);
+            if (x != NULL) continue;
+            break;
+
+        case STORE_MAP:
+            w = TOP();     /* key */
+            u = SECOND();  /* value */
+            v = THIRD();   /* dict */
+            STACKADJ(-2);
+            assert (PyDict_CheckExact(v));
+            err = PyDict_SetItem(v, w, u);  /* v[w] = u */
+            Py_DECREF(u);
+            Py_DECREF(w);
+            if (err == 0) continue;
+            break;
+
+        case MAP_ADD:
+            w = TOP();     /* key */
+            u = SECOND();  /* value */
+            STACKADJ(-2);
+            v = stack_pointer[-oparg];  /* dict */
+            assert (PyDict_CheckExact(v));
+            err = PyDict_SetItem(v, w, u);  /* v[w] = u */
+            Py_DECREF(u);
+            Py_DECREF(w);
+            if (err == 0) {
+                PREDICT(JUMP_ABSOLUTE);
+                continue;
+            }
+            break;
+
+        case LOAD_ATTR:
+            w = GETITEM(names, oparg);
+            v = TOP();
+            x = PyObject_GetAttr(v, w);
+            Py_DECREF(v);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case COMPARE_OP:
+            w = POP();
+            v = TOP();
+            if (PyInt_CheckExact(w) && PyInt_CheckExact(v)) {
+                /* INLINE: cmp(int, int) */
+                register long a, b;
+                register int res;
+                a = PyInt_AS_LONG(v);
+                b = PyInt_AS_LONG(w);
+                switch (oparg) {
+                case PyCmp_LT: res = a <  b; break;
+                case PyCmp_LE: res = a <= b; break;
+                case PyCmp_EQ: res = a == b; break;
+                case PyCmp_NE: res = a != b; break;
+                case PyCmp_GT: res = a >  b; break;
+                case PyCmp_GE: res = a >= b; break;
+                case PyCmp_IS: res = v == w; break;
+                case PyCmp_IS_NOT: res = v != w; break;
+                default: goto slow_compare;
+                }
+                x = res ? Py_True : Py_False;
+                Py_INCREF(x);
+            }
+            else {
+              slow_compare:
+                x = cmp_outcome(oparg, v, w);
+            }
+            Py_DECREF(v);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x == NULL) break;
+            PREDICT(POP_JUMP_IF_FALSE);
+            PREDICT(POP_JUMP_IF_TRUE);
+            continue;
+
+        case IMPORT_NAME:
+            w = GETITEM(names, oparg);
+            x = PyDict_GetItemString(f->f_builtins, "__import__");
+            if (x == NULL) {
+                PyErr_SetString(PyExc_ImportError,
+                                "__import__ not found");
+                break;
+            }
+            Py_INCREF(x);
+            v = POP();
+            u = TOP();
+            if (PyInt_AsLong(u) != -1 || PyErr_Occurred())
+                w = PyTuple_Pack(5,
+                            w,
+                            f->f_globals,
+                            f->f_locals == NULL ?
+                                  Py_None : f->f_locals,
+                            v,
+                            u);
+            else
+                w = PyTuple_Pack(4,
+                            w,
+                            f->f_globals,
+                            f->f_locals == NULL ?
+                                  Py_None : f->f_locals,
+                            v);
+            Py_DECREF(v);
+            Py_DECREF(u);
+            if (w == NULL) {
+                u = POP();
+                Py_DECREF(x);
+                x = NULL;
+                break;
+            }
+            READ_TIMESTAMP(intr0);
+            v = x;
+            x = PyEval_CallObject(v, w);
+            Py_DECREF(v);
+            READ_TIMESTAMP(intr1);
+            Py_DECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case IMPORT_STAR:
+            v = POP();
+            PyFrame_FastToLocals(f);
+            if ((x = f->f_locals) == NULL) {
+                PyErr_SetString(PyExc_SystemError,
+                    "no locals found during 'import *'");
+                break;
+            }
+            READ_TIMESTAMP(intr0);
+            err = import_all_from(x, v);
+            READ_TIMESTAMP(intr1);
+            PyFrame_LocalsToFast(f, 0);
+            Py_DECREF(v);
+            if (err == 0) continue;
+            break;
+
+        case IMPORT_FROM:
+            w = GETITEM(names, oparg);
+            v = TOP();
+            READ_TIMESTAMP(intr0);
+            x = import_from(v, w);
+            READ_TIMESTAMP(intr1);
+            PUSH(x);
+            if (x != NULL) continue;
+            break;
+
+        case JUMP_FORWARD:
+            JUMPBY(oparg);
+            goto fast_next_opcode;
+
+        PREDICTED_WITH_ARG(POP_JUMP_IF_FALSE);
+        case POP_JUMP_IF_FALSE:
+            w = POP();
+            if (w == Py_True) {
+                Py_DECREF(w);
+                goto fast_next_opcode;
+            }
+            if (w == Py_False) {
+                Py_DECREF(w);
+                JUMPTO(oparg);
+                goto fast_next_opcode;
+            }
+            err = PyObject_IsTrue(w);
+            Py_DECREF(w);
+            if (err > 0)
+                err = 0;
+            else if (err == 0)
+                JUMPTO(oparg);
+            else
+                break;
+            continue;
+
+        PREDICTED_WITH_ARG(POP_JUMP_IF_TRUE);
+        case POP_JUMP_IF_TRUE:
+            w = POP();
+            if (w == Py_False) {
+                Py_DECREF(w);
+                goto fast_next_opcode;
+            }
+            if (w == Py_True) {
+                Py_DECREF(w);
+                JUMPTO(oparg);
+                goto fast_next_opcode;
+            }
+            err = PyObject_IsTrue(w);
+            Py_DECREF(w);
+            if (err > 0) {
+                err = 0;
+                JUMPTO(oparg);
+            }
+            else if (err == 0)
+                ;
+            else
+                break;
+            continue;
+
+        case JUMP_IF_FALSE_OR_POP:
+            w = TOP();
+            if (w == Py_True) {
+                STACKADJ(-1);
+                Py_DECREF(w);
+                goto fast_next_opcode;
+            }
+            if (w == Py_False) {
+                JUMPTO(oparg);
+                goto fast_next_opcode;
+            }
+            err = PyObject_IsTrue(w);
+            if (err > 0) {
+                STACKADJ(-1);
+                Py_DECREF(w);
+                err = 0;
+            }
+            else if (err == 0)
+                JUMPTO(oparg);
+            else
+                break;
+            continue;
+
+        case JUMP_IF_TRUE_OR_POP:
+            w = TOP();
+            if (w == Py_False) {
+                STACKADJ(-1);
+                Py_DECREF(w);
+                goto fast_next_opcode;
+            }
+            if (w == Py_True) {
+                JUMPTO(oparg);
+                goto fast_next_opcode;
+            }
+            err = PyObject_IsTrue(w);
+            if (err > 0) {
+                err = 0;
+                JUMPTO(oparg);
+            }
+            else if (err == 0) {
+                STACKADJ(-1);
+                Py_DECREF(w);
+            }
+            else
+                break;
+            continue;
+
+        PREDICTED_WITH_ARG(JUMP_ABSOLUTE);
+        case JUMP_ABSOLUTE:
+            JUMPTO(oparg);
 #if FAST_LOOPS
-			/* Enabling this path speeds-up all while and for-loops by bypassing
-                           the per-loop checks for signals.  By default, this should be turned-off
-                           because it prevents detection of a control-break in tight loops like
-                           "while 1: pass".  Compile with this option turned-on when you need
-                           the speed-up and do not need break checking inside tight loops (ones
-                           that contain only instructions ending with goto fast_next_opcode).
-                        */
-			goto fast_next_opcode;
+            /* Enabling this path speeds-up all while and for-loops by bypassing
+               the per-loop checks for signals.  By default, this should be turned-off
+               because it prevents detection of a control-break in tight loops like
+               "while 1: pass".  Compile with this option turned-on when you need
+               the speed-up and do not need break checking inside tight loops (ones
+               that contain only instructions ending with goto fast_next_opcode).
+            */
+            goto fast_next_opcode;
 #else
-			continue;
+            continue;
 #endif
 
-		case GET_ITER:
-			/* before: [obj]; after [getiter(obj)] */
-			v = TOP();
-			x = PyObject_GetIter(v);
-			Py_DECREF(v);
-			if (x != NULL) {
-				SET_TOP(x);
-				PREDICT(FOR_ITER);
-				continue;
-			}
-			STACKADJ(-1);
-			break;
-
-		PREDICTED_WITH_ARG(FOR_ITER);
-		case FOR_ITER:
-			/* before: [iter]; after: [iter, iter()] *or* [] */
-			v = TOP();
-			x = (*v->ob_type->tp_iternext)(v);
-			if (x != NULL) {
-				PUSH(x);
-				PREDICT(STORE_FAST);
-				PREDICT(UNPACK_SEQUENCE);
-				continue;
-			}
-			if (PyErr_Occurred()) {
-				if (!PyErr_ExceptionMatches(
-						PyExc_StopIteration))
-					break;
-				PyErr_Clear();
-			}
-			/* iterator ended normally */
- 			x = v = POP();
-			Py_DECREF(v);
-			JUMPBY(oparg);
-			continue;
-
-		case BREAK_LOOP:
-			why = WHY_BREAK;
-			goto fast_block_end;
-
-		case CONTINUE_LOOP:
-			retval = PyInt_FromLong(oparg);
-			if (!retval) {
-				x = NULL;
-				break;
-			}
-			why = WHY_CONTINUE;
-			goto fast_block_end;
-
-		case SETUP_LOOP:
-		case SETUP_EXCEPT:
-		case SETUP_FINALLY:
-			/* NOTE: If you add any new block-setup opcodes that
-		           are not try/except/finally handlers, you may need
-		           to update the PyGen_NeedsFinalizing() function.
-		           */
-
-			PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
-					   STACK_LEVEL());
-			continue;
-
-		case SETUP_WITH:
-                {
-			static PyObject *exit, *enter;
-			w = TOP();
-			x = special_lookup(w, "__exit__", &exit);
-			if (!x)
-				break;
-			SET_TOP(x);
-		        u = special_lookup(w, "__enter__", &enter);
-			Py_DECREF(w);
-			if (!u) {
-				x = NULL;
-				break;
-			}
-			x = PyObject_CallFunctionObjArgs(u, NULL);
-			Py_DECREF(u);
-			if (!x)
-				break;
-			/* Setup a finally block (SETUP_WITH as a block is
-			   equivalent to SETUP_FINALLY except it normalizes
-			   the exception) before pushing the result of
-			   __enter__ on the stack. */
-			PyFrame_BlockSetup(f, SETUP_WITH, INSTR_OFFSET() + oparg,
-					   STACK_LEVEL());
-
-			PUSH(x);
-			continue;
-		}
-
-		case WITH_CLEANUP:
-		{
-			/* At the top of the stack are 1-3 values indicating
-			   how/why we entered the finally clause:
-			   - TOP = None
-			   - (TOP, SECOND) = (WHY_{RETURN,CONTINUE}), retval
-			   - TOP = WHY_*; no retval below it
-			   - (TOP, SECOND, THIRD) = exc_info()
-			   Below them is EXIT, the context.__exit__ bound method.
-			   In the last case, we must call
-			     EXIT(TOP, SECOND, THIRD)
-			   otherwise we must call
-			     EXIT(None, None, None)
-
-			   In all cases, we remove EXIT from the stack, leaving
-			   the rest in the same order.
-
-			   In addition, if the stack represents an exception,
-			   *and* the function call returns a 'true' value, we
-			   "zap" this information, to prevent END_FINALLY from
-			   re-raising the exception.  (But non-local gotos
-			   should still be resumed.)
-			*/
-
-			PyObject *exit_func;
-
-			u = POP();
-			if (u == Py_None) {
-			       	exit_func = TOP();
-				SET_TOP(u);
-				v = w = Py_None;
-			}
-			else if (PyInt_Check(u)) {
-				switch(PyInt_AS_LONG(u)) {
-				case WHY_RETURN:
-				case WHY_CONTINUE:
-					/* Retval in TOP. */
-					exit_func = SECOND();
-					SET_SECOND(TOP());
-					SET_TOP(u);
-					break;
-				default:
-					exit_func = TOP();
-					SET_TOP(u);
-					break;
-				}
-				u = v = w = Py_None;
-			}
-			else {
-				v = TOP();
-				w = SECOND();
-				exit_func = THIRD();
-				SET_TOP(u);
-				SET_SECOND(v);
-				SET_THIRD(w);
-			}
-			/* XXX Not the fastest way to call it... */
-			x = PyObject_CallFunctionObjArgs(exit_func, u, v, w,
-							 NULL);
-			Py_DECREF(exit_func);
-			if (x == NULL)
-				break; /* Go to error exit */
-
-			if (u != Py_None)
-				err = PyObject_IsTrue(x);
-			else
-				err = 0;
-			Py_DECREF(x);
-
-			if (err < 0)
-				break; /* Go to error exit */
-			else if (err > 0) {
-				err = 0;
-				/* There was an exception and a true return */
-				STACKADJ(-2);
-				Py_INCREF(Py_None);
-				SET_TOP(Py_None);
-				Py_DECREF(u);
-				Py_DECREF(v);
-				Py_DECREF(w);
-			} else {
-				/* The stack was rearranged to remove EXIT
-				   above. Let END_FINALLY do its thing */
-			}
-			PREDICT(END_FINALLY);
-			break;
-		}
-
-		case CALL_FUNCTION:
-		{
-			PyObject **sp;
-			PCALL(PCALL_ALL);
-			sp = stack_pointer;
+        case GET_ITER:
+            /* before: [obj]; after [getiter(obj)] */
+            v = TOP();
+            x = PyObject_GetIter(v);
+            Py_DECREF(v);
+            if (x != NULL) {
+                SET_TOP(x);
+                PREDICT(FOR_ITER);
+                continue;
+            }
+            STACKADJ(-1);
+            break;
+
+        PREDICTED_WITH_ARG(FOR_ITER);
+        case FOR_ITER:
+            /* before: [iter]; after: [iter, iter()] *or* [] */
+            v = TOP();
+            x = (*v->ob_type->tp_iternext)(v);
+            if (x != NULL) {
+                PUSH(x);
+                PREDICT(STORE_FAST);
+                PREDICT(UNPACK_SEQUENCE);
+                continue;
+            }
+            if (PyErr_Occurred()) {
+                if (!PyErr_ExceptionMatches(
+                                PyExc_StopIteration))
+                    break;
+                PyErr_Clear();
+            }
+            /* iterator ended normally */
+            x = v = POP();
+            Py_DECREF(v);
+            JUMPBY(oparg);
+            continue;
+
+        case BREAK_LOOP:
+            why = WHY_BREAK;
+            goto fast_block_end;
+
+        case CONTINUE_LOOP:
+            retval = PyInt_FromLong(oparg);
+            if (!retval) {
+                x = NULL;
+                break;
+            }
+            why = WHY_CONTINUE;
+            goto fast_block_end;
+
+        case SETUP_LOOP:
+        case SETUP_EXCEPT:
+        case SETUP_FINALLY:
+            /* NOTE: If you add any new block-setup opcodes that
+               are not try/except/finally handlers, you may need
+               to update the PyGen_NeedsFinalizing() function.
+               */
+
+            PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
+                               STACK_LEVEL());
+            continue;
+
+        case SETUP_WITH:
+        {
+            static PyObject *exit, *enter;
+            w = TOP();
+            x = special_lookup(w, "__exit__", &exit);
+            if (!x)
+                break;
+            SET_TOP(x);
+            u = special_lookup(w, "__enter__", &enter);
+            Py_DECREF(w);
+            if (!u) {
+                x = NULL;
+                break;
+            }
+            x = PyObject_CallFunctionObjArgs(u, NULL);
+            Py_DECREF(u);
+            if (!x)
+                break;
+            /* Setup a finally block (SETUP_WITH as a block is
+               equivalent to SETUP_FINALLY except it normalizes
+               the exception) before pushing the result of
+               __enter__ on the stack. */
+            PyFrame_BlockSetup(f, SETUP_WITH, INSTR_OFFSET() + oparg,
+                               STACK_LEVEL());
+
+            PUSH(x);
+            continue;
+        }
+
+        case WITH_CLEANUP:
+        {
+            /* At the top of the stack are 1-3 values indicating
+               how/why we entered the finally clause:
+               - TOP = None
+               - (TOP, SECOND) = (WHY_{RETURN,CONTINUE}), retval
+               - TOP = WHY_*; no retval below it
+               - (TOP, SECOND, THIRD) = exc_info()
+               Below them is EXIT, the context.__exit__ bound method.
+               In the last case, we must call
+                 EXIT(TOP, SECOND, THIRD)
+               otherwise we must call
+                 EXIT(None, None, None)
+
+               In all cases, we remove EXIT from the stack, leaving
+               the rest in the same order.
+
+               In addition, if the stack represents an exception,
+               *and* the function call returns a 'true' value, we
+               "zap" this information, to prevent END_FINALLY from
+               re-raising the exception.  (But non-local gotos
+               should still be resumed.)
+            */
+
+            PyObject *exit_func;
+
+            u = POP();
+            if (u == Py_None) {
+                exit_func = TOP();
+                SET_TOP(u);
+                v = w = Py_None;
+            }
+            else if (PyInt_Check(u)) {
+                switch(PyInt_AS_LONG(u)) {
+                case WHY_RETURN:
+                case WHY_CONTINUE:
+                    /* Retval in TOP. */
+                    exit_func = SECOND();
+                    SET_SECOND(TOP());
+                    SET_TOP(u);
+                    break;
+                default:
+                    exit_func = TOP();
+                    SET_TOP(u);
+                    break;
+                }
+                u = v = w = Py_None;
+            }
+            else {
+                v = TOP();
+                w = SECOND();
+                exit_func = THIRD();
+                SET_TOP(u);
+                SET_SECOND(v);
+                SET_THIRD(w);
+            }
+            /* XXX Not the fastest way to call it... */
+            x = PyObject_CallFunctionObjArgs(exit_func, u, v, w,
+                                             NULL);
+            Py_DECREF(exit_func);
+            if (x == NULL)
+                break; /* Go to error exit */
+
+            if (u != Py_None)
+                err = PyObject_IsTrue(x);
+            else
+                err = 0;
+            Py_DECREF(x);
+
+            if (err < 0)
+                break; /* Go to error exit */
+            else if (err > 0) {
+                err = 0;
+                /* There was an exception and a true return */
+                STACKADJ(-2);
+                Py_INCREF(Py_None);
+                SET_TOP(Py_None);
+                Py_DECREF(u);
+                Py_DECREF(v);
+                Py_DECREF(w);
+            } else {
+                /* The stack was rearranged to remove EXIT
+                   above. Let END_FINALLY do its thing */
+            }
+            PREDICT(END_FINALLY);
+            break;
+        }
+
+        case CALL_FUNCTION:
+        {
+            PyObject **sp;
+            PCALL(PCALL_ALL);
+            sp = stack_pointer;
 #ifdef WITH_TSC
-			x = call_function(&sp, oparg, &intr0, &intr1);
+            x = call_function(&sp, oparg, &intr0, &intr1);
 #else
-			x = call_function(&sp, oparg);
+            x = call_function(&sp, oparg);
 #endif
-			stack_pointer = sp;
-			PUSH(x);
-			if (x != NULL)
-				continue;
-			break;
-		}
-
-		case CALL_FUNCTION_VAR:
-		case CALL_FUNCTION_KW:
-		case CALL_FUNCTION_VAR_KW:
-		{
-		    int na = oparg & 0xff;
-		    int nk = (oparg>>8) & 0xff;
-		    int flags = (opcode - CALL_FUNCTION) & 3;
-		    int n = na + 2 * nk;
-		    PyObject **pfunc, *func, **sp;
-		    PCALL(PCALL_ALL);
-		    if (flags & CALL_FLAG_VAR)
-			    n++;
-		    if (flags & CALL_FLAG_KW)
-			    n++;
-		    pfunc = stack_pointer - n - 1;
-		    func = *pfunc;
-
-		    if (PyMethod_Check(func)
-			&& PyMethod_GET_SELF(func) != NULL) {
-			    PyObject *self = PyMethod_GET_SELF(func);
-			    Py_INCREF(self);
-			    func = PyMethod_GET_FUNCTION(func);
-			    Py_INCREF(func);
-			    Py_DECREF(*pfunc);
-			    *pfunc = self;
-			    na++;
-		    } else
-			    Py_INCREF(func);
-		    sp = stack_pointer;
-		    READ_TIMESTAMP(intr0);
-		    x = ext_do_call(func, &sp, flags, na, nk);
-		    READ_TIMESTAMP(intr1);
-		    stack_pointer = sp;
-		    Py_DECREF(func);
-
-		    while (stack_pointer > pfunc) {
-			    w = POP();
-			    Py_DECREF(w);
-		    }
-		    PUSH(x);
-		    if (x != NULL)
-			    continue;
-		    break;
-		}
-
-		case MAKE_FUNCTION:
-			v = POP(); /* code object */
-			x = PyFunction_New(v, f->f_globals);
-			Py_DECREF(v);
-			/* XXX Maybe this should be a separate opcode? */
-			if (x != NULL && oparg > 0) {
-				v = PyTuple_New(oparg);
-				if (v == NULL) {
-					Py_DECREF(x);
-					x = NULL;
-					break;
-				}
-				while (--oparg >= 0) {
-					w = POP();
-					PyTuple_SET_ITEM(v, oparg, w);
-				}
-				err = PyFunction_SetDefaults(x, v);
-				Py_DECREF(v);
-			}
-			PUSH(x);
-			break;
-
-		case MAKE_CLOSURE:
-		{
-			v = POP(); /* code object */
-			x = PyFunction_New(v, f->f_globals);
-			Py_DECREF(v);
-			if (x != NULL) {
-				v = POP();
-				if (PyFunction_SetClosure(x, v) != 0) {
-					/* Can't happen unless bytecode is corrupt. */
-					why = WHY_EXCEPTION;
-				}
-				Py_DECREF(v);
-			}
-			if (x != NULL && oparg > 0) {
-				v = PyTuple_New(oparg);
-				if (v == NULL) {
-					Py_DECREF(x);
-					x = NULL;
-					break;
-				}
-				while (--oparg >= 0) {
-					w = POP();
-					PyTuple_SET_ITEM(v, oparg, w);
-				}
-				if (PyFunction_SetDefaults(x, v) != 0) {
-					/* Can't happen unless
-                                           PyFunction_SetDefaults changes. */
-					why = WHY_EXCEPTION;
-				}
-				Py_DECREF(v);
-			}
-			PUSH(x);
-			break;
-		}
-
-		case BUILD_SLICE:
-			if (oparg == 3)
-				w = POP();
-			else
-				w = NULL;
-			v = POP();
-			u = TOP();
-			x = PySlice_New(u, v, w);
-			Py_DECREF(u);
-			Py_DECREF(v);
-			Py_XDECREF(w);
-			SET_TOP(x);
-			if (x != NULL) continue;
-			break;
-
-		case EXTENDED_ARG:
-			opcode = NEXTOP();
-			oparg = oparg<<16 | NEXTARG();
-			goto dispatch_opcode;
-
-		default:
-			fprintf(stderr,
-				"XXX lineno: %d, opcode: %d\n",
-				PyFrame_GetLineNumber(f),
-				opcode);
-			PyErr_SetString(PyExc_SystemError, "unknown opcode");
-			why = WHY_EXCEPTION;
-			break;
+            stack_pointer = sp;
+            PUSH(x);
+            if (x != NULL)
+                continue;
+            break;
+        }
+
+        case CALL_FUNCTION_VAR:
+        case CALL_FUNCTION_KW:
+        case CALL_FUNCTION_VAR_KW:
+        {
+            int na = oparg & 0xff;
+            int nk = (oparg>>8) & 0xff;
+            int flags = (opcode - CALL_FUNCTION) & 3;
+            int n = na + 2 * nk;
+            PyObject **pfunc, *func, **sp;
+            PCALL(PCALL_ALL);
+            if (flags & CALL_FLAG_VAR)
+                n++;
+            if (flags & CALL_FLAG_KW)
+                n++;
+            pfunc = stack_pointer - n - 1;
+            func = *pfunc;
+
+            if (PyMethod_Check(func)
+            && PyMethod_GET_SELF(func) != NULL) {
+                PyObject *self = PyMethod_GET_SELF(func);
+                Py_INCREF(self);
+                func = PyMethod_GET_FUNCTION(func);
+                Py_INCREF(func);
+                Py_DECREF(*pfunc);
+                *pfunc = self;
+                na++;
+            } else
+                Py_INCREF(func);
+            sp = stack_pointer;
+            READ_TIMESTAMP(intr0);
+            x = ext_do_call(func, &sp, flags, na, nk);
+            READ_TIMESTAMP(intr1);
+            stack_pointer = sp;
+            Py_DECREF(func);
+
+            while (stack_pointer > pfunc) {
+                w = POP();
+                Py_DECREF(w);
+            }
+            PUSH(x);
+            if (x != NULL)
+                continue;
+            break;
+        }
+
+        case MAKE_FUNCTION:
+            v = POP(); /* code object */
+            x = PyFunction_New(v, f->f_globals);
+            Py_DECREF(v);
+            /* XXX Maybe this should be a separate opcode? */
+            if (x != NULL && oparg > 0) {
+                v = PyTuple_New(oparg);
+                if (v == NULL) {
+                    Py_DECREF(x);
+                    x = NULL;
+                    break;
+                }
+                while (--oparg >= 0) {
+                    w = POP();
+                    PyTuple_SET_ITEM(v, oparg, w);
+                }
+                err = PyFunction_SetDefaults(x, v);
+                Py_DECREF(v);
+            }
+            PUSH(x);
+            break;
+
+        case MAKE_CLOSURE:
+        {
+            v = POP(); /* code object */
+            x = PyFunction_New(v, f->f_globals);
+            Py_DECREF(v);
+            if (x != NULL) {
+                v = POP();
+                if (PyFunction_SetClosure(x, v) != 0) {
+                    /* Can't happen unless bytecode is corrupt. */
+                    why = WHY_EXCEPTION;
+                }
+                Py_DECREF(v);
+            }
+            if (x != NULL && oparg > 0) {
+                v = PyTuple_New(oparg);
+                if (v == NULL) {
+                    Py_DECREF(x);
+                    x = NULL;
+                    break;
+                }
+                while (--oparg >= 0) {
+                    w = POP();
+                    PyTuple_SET_ITEM(v, oparg, w);
+                }
+                if (PyFunction_SetDefaults(x, v) != 0) {
+                    /* Can't happen unless
+                       PyFunction_SetDefaults changes. */
+                    why = WHY_EXCEPTION;
+                }
+                Py_DECREF(v);
+            }
+            PUSH(x);
+            break;
+        }
+
+        case BUILD_SLICE:
+            if (oparg == 3)
+                w = POP();
+            else
+                w = NULL;
+            v = POP();
+            u = TOP();
+            x = PySlice_New(u, v, w);
+            Py_DECREF(u);
+            Py_DECREF(v);
+            Py_XDECREF(w);
+            SET_TOP(x);
+            if (x != NULL) continue;
+            break;
+
+        case EXTENDED_ARG:
+            opcode = NEXTOP();
+            oparg = oparg<<16 | NEXTARG();
+            goto dispatch_opcode;
+
+        default:
+            fprintf(stderr,
+                "XXX lineno: %d, opcode: %d\n",
+                PyFrame_GetLineNumber(f),
+                opcode);
+            PyErr_SetString(PyExc_SystemError, "unknown opcode");
+            why = WHY_EXCEPTION;
+            break;
 
 #ifdef CASE_TOO_BIG
-		}
+        }
 #endif
 
-		} /* switch */
+        } /* switch */
 
-	    on_error:
+        on_error:
 
-		READ_TIMESTAMP(inst1);
+        READ_TIMESTAMP(inst1);
 
-		/* Quickly continue if no error occurred */
+        /* Quickly continue if no error occurred */
 
-		if (why == WHY_NOT) {
-			if (err == 0 && x != NULL) {
+        if (why == WHY_NOT) {
+            if (err == 0 && x != NULL) {
 #ifdef CHECKEXC
-				/* This check is expensive! */
-				if (PyErr_Occurred())
-					fprintf(stderr,
-						"XXX undetected error\n");
-				else {
+                /* This check is expensive! */
+                if (PyErr_Occurred())
+                    fprintf(stderr,
+                        "XXX undetected error\n");
+                else {
 #endif
-					READ_TIMESTAMP(loop1);
-					continue; /* Normal, fast path */
+                    READ_TIMESTAMP(loop1);
+                    continue; /* Normal, fast path */
 #ifdef CHECKEXC
-				}
+                }
 #endif
-			}
-			why = WHY_EXCEPTION;
-			x = Py_None;
-			err = 0;
-		}
-
-		/* Double-check exception status */
-
-		if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
-			if (!PyErr_Occurred()) {
-				PyErr_SetString(PyExc_SystemError,
-					"error return without exception set");
-				why = WHY_EXCEPTION;
-			}
-		}
+            }
+            why = WHY_EXCEPTION;
+            x = Py_None;
+            err = 0;
+        }
+
+        /* Double-check exception status */
+
+        if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
+            if (!PyErr_Occurred()) {
+                PyErr_SetString(PyExc_SystemError,
+                    "error return without exception set");
+                why = WHY_EXCEPTION;
+            }
+        }
 #ifdef CHECKEXC
-		else {
-			/* This check is expensive! */
-			if (PyErr_Occurred()) {
-				char buf[128];
-				sprintf(buf, "Stack unwind with exception "
-					"set and why=%d", why);
-				Py_FatalError(buf);
-			}
-		}
+        else {
+            /* This check is expensive! */
+            if (PyErr_Occurred()) {
+                char buf[128];
+                sprintf(buf, "Stack unwind with exception "
+                    "set and why=%d", why);
+                Py_FatalError(buf);
+            }
+        }
 #endif
 
-		/* Log traceback info if this is a real exception */
+        /* Log traceback info if this is a real exception */
 
-		if (why == WHY_EXCEPTION) {
-			PyTraceBack_Here(f);
+        if (why == WHY_EXCEPTION) {
+            PyTraceBack_Here(f);
 
-			if (tstate->c_tracefunc != NULL)
-				call_exc_trace(tstate->c_tracefunc,
-					       tstate->c_traceobj, f);
-		}
+            if (tstate->c_tracefunc != NULL)
+                call_exc_trace(tstate->c_tracefunc,
+                               tstate->c_traceobj, f);
+        }
 
-		/* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
+        /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
 
-		if (why == WHY_RERAISE)
-			why = WHY_EXCEPTION;
+        if (why == WHY_RERAISE)
+            why = WHY_EXCEPTION;
 
-		/* Unwind stacks if a (pseudo) exception occurred */
+        /* Unwind stacks if a (pseudo) exception occurred */
 
 fast_block_end:
-		while (why != WHY_NOT && f->f_iblock > 0) {
-			/* Peek at the current block. */
-			PyTryBlock *b = &f->f_blockstack[f->f_iblock - 1];
-
-			assert(why != WHY_YIELD);
-			if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
-				why = WHY_NOT;
-				JUMPTO(PyInt_AS_LONG(retval));
-				Py_DECREF(retval);
-				break;
-			}
-
-			/* Now we have to pop the block. */
-			f->f_iblock--;
-
-			while (STACK_LEVEL() > b->b_level) {
-				v = POP();
-				Py_XDECREF(v);
-			}
-			if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
-				why = WHY_NOT;
-				JUMPTO(b->b_handler);
-				break;
-			}
-			if (b->b_type == SETUP_FINALLY ||
-			    (b->b_type == SETUP_EXCEPT &&
-			     why == WHY_EXCEPTION) ||
-			    b->b_type == SETUP_WITH) {
-				if (why == WHY_EXCEPTION) {
-					PyObject *exc, *val, *tb;
-					PyErr_Fetch(&exc, &val, &tb);
-					if (val == NULL) {
-						val = Py_None;
-						Py_INCREF(val);
-					}
-					/* Make the raw exception data
-					   available to the handler,
-					   so a program can emulate the
-					   Python main loop.  Don't do
-					   this for 'finally'. */
-					if (b->b_type == SETUP_EXCEPT ||
-					    b->b_type == SETUP_WITH) {
-						PyErr_NormalizeException(
-							&exc, &val, &tb);
-						set_exc_info(tstate,
-							     exc, val, tb);
-					}
-					if (tb == NULL) {
-						Py_INCREF(Py_None);
-						PUSH(Py_None);
-					} else
-						PUSH(tb);
-					PUSH(val);
-					PUSH(exc);
-				}
-				else {
-					if (why & (WHY_RETURN | WHY_CONTINUE))
-						PUSH(retval);
-					v = PyInt_FromLong((long)why);
-					PUSH(v);
-				}
-				why = WHY_NOT;
-				JUMPTO(b->b_handler);
-				break;
-			}
-		} /* unwind stack */
-
-		/* End the loop if we still have an error (or return) */
-
-		if (why != WHY_NOT)
-			break;
-		READ_TIMESTAMP(loop1);
-
-	} /* main loop */
-
-	assert(why != WHY_YIELD);
-	/* Pop remaining stack entries. */
-	while (!EMPTY()) {
-		v = POP();
-		Py_XDECREF(v);
-	}
-
-	if (why != WHY_RETURN)
-		retval = NULL;
+        while (why != WHY_NOT && f->f_iblock > 0) {
+            /* Peek at the current block. */
+            PyTryBlock *b = &f->f_blockstack[f->f_iblock - 1];
+
+            assert(why != WHY_YIELD);
+            if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
+                why = WHY_NOT;
+                JUMPTO(PyInt_AS_LONG(retval));
+                Py_DECREF(retval);
+                break;
+            }
+
+            /* Now we have to pop the block. */
+            f->f_iblock--;
+
+            while (STACK_LEVEL() > b->b_level) {
+                v = POP();
+                Py_XDECREF(v);
+            }
+            if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
+                why = WHY_NOT;
+                JUMPTO(b->b_handler);
+                break;
+            }
+            if (b->b_type == SETUP_FINALLY ||
+                (b->b_type == SETUP_EXCEPT &&
+                 why == WHY_EXCEPTION) ||
+                b->b_type == SETUP_WITH) {
+                if (why == WHY_EXCEPTION) {
+                    PyObject *exc, *val, *tb;
+                    PyErr_Fetch(&exc, &val, &tb);
+                    if (val == NULL) {
+                        val = Py_None;
+                        Py_INCREF(val);
+                    }
+                    /* Make the raw exception data
+                       available to the handler,
+                       so a program can emulate the
+                       Python main loop.  Don't do
+                       this for 'finally'. */
+                    if (b->b_type == SETUP_EXCEPT ||
+                        b->b_type == SETUP_WITH) {
+                        PyErr_NormalizeException(
+                            &exc, &val, &tb);
+                        set_exc_info(tstate,
+                                     exc, val, tb);
+                    }
+                    if (tb == NULL) {
+                        Py_INCREF(Py_None);
+                        PUSH(Py_None);
+                    } else
+                        PUSH(tb);
+                    PUSH(val);
+                    PUSH(exc);
+                }
+                else {
+                    if (why & (WHY_RETURN | WHY_CONTINUE))
+                        PUSH(retval);
+                    v = PyInt_FromLong((long)why);
+                    PUSH(v);
+                }
+                why = WHY_NOT;
+                JUMPTO(b->b_handler);
+                break;
+            }
+        } /* unwind stack */
+
+        /* End the loop if we still have an error (or return) */
+
+        if (why != WHY_NOT)
+            break;
+        READ_TIMESTAMP(loop1);
+
+    } /* main loop */
+
+    assert(why != WHY_YIELD);
+    /* Pop remaining stack entries. */
+    while (!EMPTY()) {
+        v = POP();
+        Py_XDECREF(v);
+    }
+
+    if (why != WHY_RETURN)
+        retval = NULL;
 
 fast_yield:
-	if (tstate->use_tracing) {
-		if (tstate->c_tracefunc) {
-			if (why == WHY_RETURN || why == WHY_YIELD) {
-				if (call_trace(tstate->c_tracefunc,
-					       tstate->c_traceobj, f,
-					       PyTrace_RETURN, retval)) {
-					Py_XDECREF(retval);
-					retval = NULL;
-					why = WHY_EXCEPTION;
-				}
-			}
-			else if (why == WHY_EXCEPTION) {
-				call_trace_protected(tstate->c_tracefunc,
-						     tstate->c_traceobj, f,
-						     PyTrace_RETURN, NULL);
-			}
-		}
-		if (tstate->c_profilefunc) {
-			if (why == WHY_EXCEPTION)
-				call_trace_protected(tstate->c_profilefunc,
-						     tstate->c_profileobj, f,
-						     PyTrace_RETURN, NULL);
-			else if (call_trace(tstate->c_profilefunc,
-					    tstate->c_profileobj, f,
-					    PyTrace_RETURN, retval)) {
-				Py_XDECREF(retval);
-				retval = NULL;
-				why = WHY_EXCEPTION;
-			}
-		}
-	}
-
-	if (tstate->frame->f_exc_type != NULL)
-		reset_exc_info(tstate);
-	else {
-		assert(tstate->frame->f_exc_value == NULL);
-		assert(tstate->frame->f_exc_traceback == NULL);
-	}
-
-	/* pop frame */
+    if (tstate->use_tracing) {
+        if (tstate->c_tracefunc) {
+            if (why == WHY_RETURN || why == WHY_YIELD) {
+                if (call_trace(tstate->c_tracefunc,
+                               tstate->c_traceobj, f,
+                               PyTrace_RETURN, retval)) {
+                    Py_XDECREF(retval);
+                    retval = NULL;
+                    why = WHY_EXCEPTION;
+                }
+            }
+            else if (why == WHY_EXCEPTION) {
+                call_trace_protected(tstate->c_tracefunc,
+                                     tstate->c_traceobj, f,
+                                     PyTrace_RETURN, NULL);
+            }
+        }
+        if (tstate->c_profilefunc) {
+            if (why == WHY_EXCEPTION)
+                call_trace_protected(tstate->c_profilefunc,
+                                     tstate->c_profileobj, f,
+                                     PyTrace_RETURN, NULL);
+            else if (call_trace(tstate->c_profilefunc,
+                                tstate->c_profileobj, f,
+                                PyTrace_RETURN, retval)) {
+                Py_XDECREF(retval);
+                retval = NULL;
+                why = WHY_EXCEPTION;
+            }
+        }
+    }
+
+    if (tstate->frame->f_exc_type != NULL)
+        reset_exc_info(tstate);
+    else {
+        assert(tstate->frame->f_exc_value == NULL);
+        assert(tstate->frame->f_exc_traceback == NULL);
+    }
+
+    /* pop frame */
 exit_eval_frame:
-	Py_LeaveRecursiveCall();
-	tstate->frame = f->f_back;
+    Py_LeaveRecursiveCall();
+    tstate->frame = f->f_back;
 
-	return retval;
+    return retval;
 }
 
 /* This is gonna seem *real weird*, but if you put some other code between
@@ -3012,291 +3012,291 @@ exit_eval_frame:
 
 PyObject *
 PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals,
-	   PyObject **args, int argcount, PyObject **kws, int kwcount,
-	   PyObject **defs, int defcount, PyObject *closure)
+           PyObject **args, int argcount, PyObject **kws, int kwcount,
+           PyObject **defs, int defcount, PyObject *closure)
 {
-	register PyFrameObject *f;
-	register PyObject *retval = NULL;
-	register PyObject **fastlocals, **freevars;
-	PyThreadState *tstate = PyThreadState_GET();
-	PyObject *x, *u;
-
-	if (globals == NULL) {
-		PyErr_SetString(PyExc_SystemError,
-				"PyEval_EvalCodeEx: NULL globals");
-		return NULL;
-	}
-
-	assert(tstate != NULL);
-	assert(globals != NULL);
-	f = PyFrame_New(tstate, co, globals, locals);
-	if (f == NULL)
-		return NULL;
-
-	fastlocals = f->f_localsplus;
-	freevars = f->f_localsplus + co->co_nlocals;
-
-	if (co->co_argcount > 0 ||
-	    co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) {
-		int i;
-		int n = argcount;
-		PyObject *kwdict = NULL;
-		if (co->co_flags & CO_VARKEYWORDS) {
-			kwdict = PyDict_New();
-			if (kwdict == NULL)
-				goto fail;
-			i = co->co_argcount;
-			if (co->co_flags & CO_VARARGS)
-				i++;
-			SETLOCAL(i, kwdict);
-		}
-		if (argcount > co->co_argcount) {
-			if (!(co->co_flags & CO_VARARGS)) {
-				PyErr_Format(PyExc_TypeError,
-				    "%.200s() takes %s %d "
-				    "argument%s (%d given)",
-				    PyString_AsString(co->co_name),
-				    defcount ? "at most" : "exactly",
-				    co->co_argcount,
-				    co->co_argcount == 1 ? "" : "s",
-				    argcount + kwcount);
-				goto fail;
-			}
-			n = co->co_argcount;
-		}
-		for (i = 0; i < n; i++) {
-			x = args[i];
-			Py_INCREF(x);
-			SETLOCAL(i, x);
-		}
-		if (co->co_flags & CO_VARARGS) {
-			u = PyTuple_New(argcount - n);
-			if (u == NULL)
-				goto fail;
-			SETLOCAL(co->co_argcount, u);
-			for (i = n; i < argcount; i++) {
-				x = args[i];
-				Py_INCREF(x);
-				PyTuple_SET_ITEM(u, i-n, x);
-			}
-		}
-		for (i = 0; i < kwcount; i++) {
-			PyObject **co_varnames;
-			PyObject *keyword = kws[2*i];
-			PyObject *value = kws[2*i + 1];
-			int j;
-			if (keyword == NULL || !(PyString_Check(keyword)
+    register PyFrameObject *f;
+    register PyObject *retval = NULL;
+    register PyObject **fastlocals, **freevars;
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *x, *u;
+
+    if (globals == NULL) {
+        PyErr_SetString(PyExc_SystemError,
+                        "PyEval_EvalCodeEx: NULL globals");
+        return NULL;
+    }
+
+    assert(tstate != NULL);
+    assert(globals != NULL);
+    f = PyFrame_New(tstate, co, globals, locals);
+    if (f == NULL)
+        return NULL;
+
+    fastlocals = f->f_localsplus;
+    freevars = f->f_localsplus + co->co_nlocals;
+
+    if (co->co_argcount > 0 ||
+        co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) {
+        int i;
+        int n = argcount;
+        PyObject *kwdict = NULL;
+        if (co->co_flags & CO_VARKEYWORDS) {
+            kwdict = PyDict_New();
+            if (kwdict == NULL)
+                goto fail;
+            i = co->co_argcount;
+            if (co->co_flags & CO_VARARGS)
+                i++;
+            SETLOCAL(i, kwdict);
+        }
+        if (argcount > co->co_argcount) {
+            if (!(co->co_flags & CO_VARARGS)) {
+                PyErr_Format(PyExc_TypeError,
+                    "%.200s() takes %s %d "
+                    "argument%s (%d given)",
+                    PyString_AsString(co->co_name),
+                    defcount ? "at most" : "exactly",
+                    co->co_argcount,
+                    co->co_argcount == 1 ? "" : "s",
+                    argcount + kwcount);
+                goto fail;
+            }
+            n = co->co_argcount;
+        }
+        for (i = 0; i < n; i++) {
+            x = args[i];
+            Py_INCREF(x);
+            SETLOCAL(i, x);
+        }
+        if (co->co_flags & CO_VARARGS) {
+            u = PyTuple_New(argcount - n);
+            if (u == NULL)
+                goto fail;
+            SETLOCAL(co->co_argcount, u);
+            for (i = n; i < argcount; i++) {
+                x = args[i];
+                Py_INCREF(x);
+                PyTuple_SET_ITEM(u, i-n, x);
+            }
+        }
+        for (i = 0; i < kwcount; i++) {
+            PyObject **co_varnames;
+            PyObject *keyword = kws[2*i];
+            PyObject *value = kws[2*i + 1];
+            int j;
+            if (keyword == NULL || !(PyString_Check(keyword)
 #ifdef Py_USING_UNICODE
-						 || PyUnicode_Check(keyword)
+                                     || PyUnicode_Check(keyword)
 #endif
-				    )) {
-				PyErr_Format(PyExc_TypeError,
-				    "%.200s() keywords must be strings",
-				    PyString_AsString(co->co_name));
-				goto fail;
-			}
-			/* Speed hack: do raw pointer compares. As names are
-			   normally interned this should almost always hit. */
-			co_varnames = ((PyTupleObject *)(co->co_varnames))->ob_item;
-			for (j = 0; j < co->co_argcount; j++) {
-				PyObject *nm = co_varnames[j];
-				if (nm == keyword)
-					goto kw_found;
-			}
-			/* Slow fallback, just in case */
-			for (j = 0; j < co->co_argcount; j++) {
-				PyObject *nm = co_varnames[j];
-				int cmp = PyObject_RichCompareBool(
-					keyword, nm, Py_EQ);
-				if (cmp > 0)
-					goto kw_found;
-				else if (cmp < 0)
-					goto fail;
-			}
-			if (kwdict == NULL) {
-				PyObject *kwd_str = kwd_as_string(keyword);
-				if (kwd_str) {
-					PyErr_Format(PyExc_TypeError,
-						     "%.200s() got an unexpected "
-						     "keyword argument '%.400s'",
-						     PyString_AsString(co->co_name),
-						     PyString_AsString(kwd_str));
-					Py_DECREF(kwd_str);
-				}
-				goto fail;
-			}
-			PyDict_SetItem(kwdict, keyword, value);
-			continue;
-		  kw_found:
-			if (GETLOCAL(j) != NULL) {
-				PyObject *kwd_str = kwd_as_string(keyword);
-				if (kwd_str) {
-					PyErr_Format(PyExc_TypeError,
-						     "%.200s() got multiple "
-						     "values for keyword "
-						     "argument '%.400s'",
-						     PyString_AsString(co->co_name),
-						     PyString_AsString(kwd_str));
-					Py_DECREF(kwd_str);
-				}
-				goto fail;
-			}
-			Py_INCREF(value);
-			SETLOCAL(j, value);
-		}
-		if (argcount < co->co_argcount) {
-			int m = co->co_argcount - defcount;
-			for (i = argcount; i < m; i++) {
-				if (GETLOCAL(i) == NULL) {
-					int j, given = 0;
-					for (j = 0; j < co->co_argcount; j++)
-						if (GETLOCAL(j))
-							given++;
-					PyErr_Format(PyExc_TypeError,
-					    "%.200s() takes %s %d "
-					    "argument%s (%d given)",
-					    PyString_AsString(co->co_name),
-					    ((co->co_flags & CO_VARARGS) ||
-					     defcount) ? "at least"
-						       : "exactly",
-					    m, m == 1 ? "" : "s", given);
-					goto fail;
-				}
-			}
-			if (n > m)
-				i = n - m;
-			else
-				i = 0;
-			for (; i < defcount; i++) {
-				if (GETLOCAL(m+i) == NULL) {
-					PyObject *def = defs[i];
-					Py_INCREF(def);
-					SETLOCAL(m+i, def);
-				}
-			}
-		}
-	}
-	else if (argcount > 0 || kwcount > 0) {
-		PyErr_Format(PyExc_TypeError,
-			     "%.200s() takes no arguments (%d given)",
-			     PyString_AsString(co->co_name),
-			     argcount + kwcount);
-		goto fail;
-	}
-	/* Allocate and initialize storage for cell vars, and copy free
-	   vars into frame.  This isn't too efficient right now. */
-	if (PyTuple_GET_SIZE(co->co_cellvars)) {
-		int i, j, nargs, found;
-		char *cellname, *argname;
-		PyObject *c;
-
-		nargs = co->co_argcount;
-		if (co->co_flags & CO_VARARGS)
-			nargs++;
-		if (co->co_flags & CO_VARKEYWORDS)
-			nargs++;
-
-		/* Initialize each cell var, taking into account
-		   cell vars that are initialized from arguments.
-
-		   Should arrange for the compiler to put cellvars
-		   that are arguments at the beginning of the cellvars
-		   list so that we can march over it more efficiently?
-		*/
-		for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
-			cellname = PyString_AS_STRING(
-				PyTuple_GET_ITEM(co->co_cellvars, i));
-			found = 0;
-			for (j = 0; j < nargs; j++) {
-				argname = PyString_AS_STRING(
-					PyTuple_GET_ITEM(co->co_varnames, j));
-				if (strcmp(cellname, argname) == 0) {
-					c = PyCell_New(GETLOCAL(j));
-					if (c == NULL)
-						goto fail;
-					GETLOCAL(co->co_nlocals + i) = c;
-					found = 1;
-					break;
-				}
-			}
-			if (found == 0) {
-				c = PyCell_New(NULL);
-				if (c == NULL)
-					goto fail;
-				SETLOCAL(co->co_nlocals + i, c);
-			}
-		}
-	}
-	if (PyTuple_GET_SIZE(co->co_freevars)) {
-		int i;
-		for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) {
-			PyObject *o = PyTuple_GET_ITEM(closure, i);
-			Py_INCREF(o);
-			freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
-		}
-	}
-
-	if (co->co_flags & CO_GENERATOR) {
-		/* Don't need to keep the reference to f_back, it will be set
-		 * when the generator is resumed. */
-		Py_XDECREF(f->f_back);
-		f->f_back = NULL;
-
-		PCALL(PCALL_GENERATOR);
-
-		/* Create a new generator that owns the ready to run frame
-		 * and return that as the value. */
-		return PyGen_New(f);
-	}
-
-	retval = PyEval_EvalFrameEx(f,0);
+                        )) {
+                PyErr_Format(PyExc_TypeError,
+                    "%.200s() keywords must be strings",
+                    PyString_AsString(co->co_name));
+                goto fail;
+            }
+            /* Speed hack: do raw pointer compares. As names are
+               normally interned this should almost always hit. */
+            co_varnames = ((PyTupleObject *)(co->co_varnames))->ob_item;
+            for (j = 0; j < co->co_argcount; j++) {
+                PyObject *nm = co_varnames[j];
+                if (nm == keyword)
+                    goto kw_found;
+            }
+            /* Slow fallback, just in case */
+            for (j = 0; j < co->co_argcount; j++) {
+                PyObject *nm = co_varnames[j];
+                int cmp = PyObject_RichCompareBool(
+                    keyword, nm, Py_EQ);
+                if (cmp > 0)
+                    goto kw_found;
+                else if (cmp < 0)
+                    goto fail;
+            }
+            if (kwdict == NULL) {
+                PyObject *kwd_str = kwd_as_string(keyword);
+                if (kwd_str) {
+                    PyErr_Format(PyExc_TypeError,
+                                 "%.200s() got an unexpected "
+                                 "keyword argument '%.400s'",
+                                 PyString_AsString(co->co_name),
+                                 PyString_AsString(kwd_str));
+                    Py_DECREF(kwd_str);
+                }
+                goto fail;
+            }
+            PyDict_SetItem(kwdict, keyword, value);
+            continue;
+          kw_found:
+            if (GETLOCAL(j) != NULL) {
+                PyObject *kwd_str = kwd_as_string(keyword);
+                if (kwd_str) {
+                    PyErr_Format(PyExc_TypeError,
+                                 "%.200s() got multiple "
+                                 "values for keyword "
+                                 "argument '%.400s'",
+                                 PyString_AsString(co->co_name),
+                                 PyString_AsString(kwd_str));
+                    Py_DECREF(kwd_str);
+                }
+                goto fail;
+            }
+            Py_INCREF(value);
+            SETLOCAL(j, value);
+        }
+        if (argcount < co->co_argcount) {
+            int m = co->co_argcount - defcount;
+            for (i = argcount; i < m; i++) {
+                if (GETLOCAL(i) == NULL) {
+                    int j, given = 0;
+                    for (j = 0; j < co->co_argcount; j++)
+                        if (GETLOCAL(j))
+                            given++;
+                    PyErr_Format(PyExc_TypeError,
+                        "%.200s() takes %s %d "
+                        "argument%s (%d given)",
+                        PyString_AsString(co->co_name),
+                        ((co->co_flags & CO_VARARGS) ||
+                         defcount) ? "at least"
+                                   : "exactly",
+                        m, m == 1 ? "" : "s", given);
+                    goto fail;
+                }
+            }
+            if (n > m)
+                i = n - m;
+            else
+                i = 0;
+            for (; i < defcount; i++) {
+                if (GETLOCAL(m+i) == NULL) {
+                    PyObject *def = defs[i];
+                    Py_INCREF(def);
+                    SETLOCAL(m+i, def);
+                }
+            }
+        }
+    }
+    else if (argcount > 0 || kwcount > 0) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no arguments (%d given)",
+                     PyString_AsString(co->co_name),
+                     argcount + kwcount);
+        goto fail;
+    }
+    /* Allocate and initialize storage for cell vars, and copy free
+       vars into frame.  This isn't too efficient right now. */
+    if (PyTuple_GET_SIZE(co->co_cellvars)) {
+        int i, j, nargs, found;
+        char *cellname, *argname;
+        PyObject *c;
+
+        nargs = co->co_argcount;
+        if (co->co_flags & CO_VARARGS)
+            nargs++;
+        if (co->co_flags & CO_VARKEYWORDS)
+            nargs++;
+
+        /* Initialize each cell var, taking into account
+           cell vars that are initialized from arguments.
+
+           Should arrange for the compiler to put cellvars
+           that are arguments at the beginning of the cellvars
+           list so that we can march over it more efficiently?
+        */
+        for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
+            cellname = PyString_AS_STRING(
+                PyTuple_GET_ITEM(co->co_cellvars, i));
+            found = 0;
+            for (j = 0; j < nargs; j++) {
+                argname = PyString_AS_STRING(
+                    PyTuple_GET_ITEM(co->co_varnames, j));
+                if (strcmp(cellname, argname) == 0) {
+                    c = PyCell_New(GETLOCAL(j));
+                    if (c == NULL)
+                        goto fail;
+                    GETLOCAL(co->co_nlocals + i) = c;
+                    found = 1;
+                    break;
+                }
+            }
+            if (found == 0) {
+                c = PyCell_New(NULL);
+                if (c == NULL)
+                    goto fail;
+                SETLOCAL(co->co_nlocals + i, c);
+            }
+        }
+    }
+    if (PyTuple_GET_SIZE(co->co_freevars)) {
+        int i;
+        for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) {
+            PyObject *o = PyTuple_GET_ITEM(closure, i);
+            Py_INCREF(o);
+            freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
+        }
+    }
+
+    if (co->co_flags & CO_GENERATOR) {
+        /* Don't need to keep the reference to f_back, it will be set
+         * when the generator is resumed. */
+        Py_XDECREF(f->f_back);
+        f->f_back = NULL;
+
+        PCALL(PCALL_GENERATOR);
+
+        /* Create a new generator that owns the ready to run frame
+         * and return that as the value. */
+        return PyGen_New(f);
+    }
+
+    retval = PyEval_EvalFrameEx(f,0);
 
 fail: /* Jump here from prelude on failure */
 
-	/* decref'ing the frame can cause __del__ methods to get invoked,
-	   which can call back into Python.  While we're done with the
-	   current Python frame (f), the associated C stack is still in use,
-	   so recursion_depth must be boosted for the duration.
-	*/
-	assert(tstate != NULL);
-	++tstate->recursion_depth;
-	Py_DECREF(f);
-	--tstate->recursion_depth;
-	return retval;
+    /* decref'ing the frame can cause __del__ methods to get invoked,
+       which can call back into Python.  While we're done with the
+       current Python frame (f), the associated C stack is still in use,
+       so recursion_depth must be boosted for the duration.
+    */
+    assert(tstate != NULL);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return retval;
 }
 
 
 static PyObject *
 special_lookup(PyObject *o, char *meth, PyObject **cache)
 {
-	PyObject *res;
-	if (PyInstance_Check(o)) {
-		if (!*cache)
-			return PyObject_GetAttrString(o, meth);
-		else
-			return PyObject_GetAttr(o, *cache);
-	}
-	res = _PyObject_LookupSpecial(o, meth, cache);
-	if (res == NULL && !PyErr_Occurred()) {
-		PyErr_SetObject(PyExc_AttributeError, *cache);
-		return NULL;
-	}
-	return res;
+    PyObject *res;
+    if (PyInstance_Check(o)) {
+        if (!*cache)
+            return PyObject_GetAttrString(o, meth);
+        else
+            return PyObject_GetAttr(o, *cache);
+    }
+    res = _PyObject_LookupSpecial(o, meth, cache);
+    if (res == NULL && !PyErr_Occurred()) {
+        PyErr_SetObject(PyExc_AttributeError, *cache);
+        return NULL;
+    }
+    return res;
 }
 
 
 static PyObject *
 kwd_as_string(PyObject *kwd) {
 #ifdef Py_USING_UNICODE
-	if (PyString_Check(kwd)) {
+    if (PyString_Check(kwd)) {
 #else
-		assert(PyString_Check(kwd));
+        assert(PyString_Check(kwd));
 #endif
-		Py_INCREF(kwd);
-		return kwd;
+        Py_INCREF(kwd);
+        return kwd;
 #ifdef Py_USING_UNICODE
-	}
-	return _PyUnicode_AsDefaultEncodedString(kwd, "replace");
+    }
+    return _PyUnicode_AsDefaultEncodedString(kwd, "replace");
 #endif
 }
 
@@ -3324,10 +3324,10 @@ kwd_as_string(PyObject *kwd) {
   this:
 
      try:
-	"something that may fail"
+    "something that may fail"
      except "some exception":
-	"do something else first"
-	"print the exception from sys.exc_ZZZ."
+    "do something else first"
+    "print the exception from sys.exc_ZZZ."
 
   if "do something else first" invoked something that raised and caught
   an exception, sys.exc_ZZZ were overwritten.  That was a frequent
@@ -3365,92 +3365,92 @@ kwd_as_string(PyObject *kwd) {
 
 static void
 set_exc_info(PyThreadState *tstate,
-	     PyObject *type, PyObject *value, PyObject *tb)
+             PyObject *type, PyObject *value, PyObject *tb)
 {
-	PyFrameObject *frame = tstate->frame;
-	PyObject *tmp_type, *tmp_value, *tmp_tb;
-
-	assert(type != NULL);
-	assert(frame != NULL);
-	if (frame->f_exc_type == NULL) {
-		assert(frame->f_exc_value == NULL);
-		assert(frame->f_exc_traceback == NULL);
-		/* This frame didn't catch an exception before. */
-		/* Save previous exception of this thread in this frame. */
-		if (tstate->exc_type == NULL) {
-			/* XXX Why is this set to Py_None? */
-			Py_INCREF(Py_None);
-			tstate->exc_type = Py_None;
-		}
-		Py_INCREF(tstate->exc_type);
-		Py_XINCREF(tstate->exc_value);
-		Py_XINCREF(tstate->exc_traceback);
-		frame->f_exc_type = tstate->exc_type;
-		frame->f_exc_value = tstate->exc_value;
-		frame->f_exc_traceback = tstate->exc_traceback;
-	}
-	/* Set new exception for this thread. */
-	tmp_type = tstate->exc_type;
-	tmp_value = tstate->exc_value;
-	tmp_tb = tstate->exc_traceback;
-	Py_INCREF(type);
-	Py_XINCREF(value);
-	Py_XINCREF(tb);
-	tstate->exc_type = type;
-	tstate->exc_value = value;
-	tstate->exc_traceback = tb;
-	Py_XDECREF(tmp_type);
-	Py_XDECREF(tmp_value);
-	Py_XDECREF(tmp_tb);
-	/* For b/w compatibility */
-	PySys_SetObject("exc_type", type);
-	PySys_SetObject("exc_value", value);
-	PySys_SetObject("exc_traceback", tb);
+    PyFrameObject *frame = tstate->frame;
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+
+    assert(type != NULL);
+    assert(frame != NULL);
+    if (frame->f_exc_type == NULL) {
+        assert(frame->f_exc_value == NULL);
+        assert(frame->f_exc_traceback == NULL);
+        /* This frame didn't catch an exception before. */
+        /* Save previous exception of this thread in this frame. */
+        if (tstate->exc_type == NULL) {
+            /* XXX Why is this set to Py_None? */
+            Py_INCREF(Py_None);
+            tstate->exc_type = Py_None;
+        }
+        Py_INCREF(tstate->exc_type);
+        Py_XINCREF(tstate->exc_value);
+        Py_XINCREF(tstate->exc_traceback);
+        frame->f_exc_type = tstate->exc_type;
+        frame->f_exc_value = tstate->exc_value;
+        frame->f_exc_traceback = tstate->exc_traceback;
+    }
+    /* Set new exception for this thread. */
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    Py_INCREF(type);
+    Py_XINCREF(value);
+    Py_XINCREF(tb);
+    tstate->exc_type = type;
+    tstate->exc_value = value;
+    tstate->exc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+    /* For b/w compatibility */
+    PySys_SetObject("exc_type", type);
+    PySys_SetObject("exc_value", value);
+    PySys_SetObject("exc_traceback", tb);
 }
 
 static void
 reset_exc_info(PyThreadState *tstate)
 {
-	PyFrameObject *frame;
-	PyObject *tmp_type, *tmp_value, *tmp_tb;
-
-	/* It's a precondition that the thread state's frame caught an
-	 * exception -- verify in a debug build.
-	 */
-	assert(tstate != NULL);
-	frame = tstate->frame;
-	assert(frame != NULL);
-	assert(frame->f_exc_type != NULL);
-
-	/* Copy the frame's exception info back to the thread state. */
-	tmp_type = tstate->exc_type;
-	tmp_value = tstate->exc_value;
-	tmp_tb = tstate->exc_traceback;
-	Py_INCREF(frame->f_exc_type);
-	Py_XINCREF(frame->f_exc_value);
-	Py_XINCREF(frame->f_exc_traceback);
-	tstate->exc_type = frame->f_exc_type;
-	tstate->exc_value = frame->f_exc_value;
-	tstate->exc_traceback = frame->f_exc_traceback;
-	Py_XDECREF(tmp_type);
-	Py_XDECREF(tmp_value);
-	Py_XDECREF(tmp_tb);
-
-	/* For b/w compatibility */
-	PySys_SetObject("exc_type", frame->f_exc_type);
-	PySys_SetObject("exc_value", frame->f_exc_value);
-	PySys_SetObject("exc_traceback", frame->f_exc_traceback);
-
-	/* Clear the frame's exception info. */
-	tmp_type = frame->f_exc_type;
-	tmp_value = frame->f_exc_value;
-	tmp_tb = frame->f_exc_traceback;
-	frame->f_exc_type = NULL;
-	frame->f_exc_value = NULL;
-	frame->f_exc_traceback = NULL;
-	Py_DECREF(tmp_type);
-	Py_XDECREF(tmp_value);
-	Py_XDECREF(tmp_tb);
+    PyFrameObject *frame;
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+
+    /* It's a precondition that the thread state's frame caught an
+     * exception -- verify in a debug build.
+     */
+    assert(tstate != NULL);
+    frame = tstate->frame;
+    assert(frame != NULL);
+    assert(frame->f_exc_type != NULL);
+
+    /* Copy the frame's exception info back to the thread state. */
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    Py_INCREF(frame->f_exc_type);
+    Py_XINCREF(frame->f_exc_value);
+    Py_XINCREF(frame->f_exc_traceback);
+    tstate->exc_type = frame->f_exc_type;
+    tstate->exc_value = frame->f_exc_value;
+    tstate->exc_traceback = frame->f_exc_traceback;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+
+    /* For b/w compatibility */
+    PySys_SetObject("exc_type", frame->f_exc_type);
+    PySys_SetObject("exc_value", frame->f_exc_value);
+    PySys_SetObject("exc_traceback", frame->f_exc_traceback);
+
+    /* Clear the frame's exception info. */
+    tmp_type = frame->f_exc_type;
+    tmp_value = frame->f_exc_value;
+    tmp_tb = frame->f_exc_traceback;
+    frame->f_exc_type = NULL;
+    frame->f_exc_value = NULL;
+    frame->f_exc_traceback = NULL;
+    Py_DECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
 }
 
 /* Logic for the raise statement (too complicated for inlining).
@@ -3458,108 +3458,108 @@ reset_exc_info(PyThreadState *tstate)
 static enum why_code
 do_raise(PyObject *type, PyObject *value, PyObject *tb)
 {
-	if (type == NULL) {
-		/* Reraise */
-		PyThreadState *tstate = PyThreadState_GET();
-		type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
-		value = tstate->exc_value;
-		tb = tstate->exc_traceback;
-		Py_XINCREF(type);
-		Py_XINCREF(value);
-		Py_XINCREF(tb);
-	}
-
-	/* We support the following forms of raise:
-	   raise <class>, <classinstance>
-	   raise <class>, <argument tuple>
-	   raise <class>, None
-	   raise <class>, <argument>
-	   raise <classinstance>, None
-	   raise <string>, <object>
-	   raise <string>, None
-
-	   An omitted second argument is the same as None.
-
-	   In addition, raise <tuple>, <anything> is the same as
-	   raising the tuple's first item (and it better have one!);
-	   this rule is applied recursively.
-
-	   Finally, an optional third argument can be supplied, which
-	   gives the traceback to be substituted (useful when
-	   re-raising an exception after examining it).  */
-
-	/* First, check the traceback argument, replacing None with
-	   NULL. */
-	if (tb == Py_None) {
-		Py_DECREF(tb);
-		tb = NULL;
-	}
-	else if (tb != NULL && !PyTraceBack_Check(tb)) {
-		PyErr_SetString(PyExc_TypeError,
-			   "raise: arg 3 must be a traceback or None");
-		goto raise_error;
-	}
-
-	/* Next, replace a missing value with None */
-	if (value == NULL) {
-		value = Py_None;
-		Py_INCREF(value);
-	}
-
-	/* Next, repeatedly, replace a tuple exception with its first item */
-	while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
-		PyObject *tmp = type;
-		type = PyTuple_GET_ITEM(type, 0);
-		Py_INCREF(type);
-		Py_DECREF(tmp);
-	}
-
-	if (PyExceptionClass_Check(type))
-		PyErr_NormalizeException(&type, &value, &tb);
-
-	else if (PyExceptionInstance_Check(type)) {
-		/* Raising an instance.  The value should be a dummy. */
-		if (value != Py_None) {
-			PyErr_SetString(PyExc_TypeError,
-			  "instance exception may not have a separate value");
-			goto raise_error;
-		}
-		else {
-			/* Normalize to raise <class>, <instance> */
-			Py_DECREF(value);
-			value = type;
-			type = PyExceptionInstance_Class(type);
-			Py_INCREF(type);
-		}
-	}
-	else {
-		/* Not something you can raise.  You get an exception
-		   anyway, just not what you specified :-) */
-		PyErr_Format(PyExc_TypeError,
-			     "exceptions must be old-style classes or "
-			     "derived from BaseException, not %s",
-			     type->ob_type->tp_name);
-		goto raise_error;
-	}
-
-	assert(PyExceptionClass_Check(type));
-	if (Py_Py3kWarningFlag && PyClass_Check(type)) {
-		if (PyErr_WarnEx(PyExc_DeprecationWarning,
-				"exceptions must derive from BaseException "
-				"in 3.x", 1) < 0)
-			goto raise_error;
-	}
-
-	PyErr_Restore(type, value, tb);
-	if (tb == NULL)
-		return WHY_EXCEPTION;
-	else
-		return WHY_RERAISE;
+    if (type == NULL) {
+        /* Reraise */
+        PyThreadState *tstate = PyThreadState_GET();
+        type = tstate->exc_type == NULL ? Py_None : tstate->exc_type;
+        value = tstate->exc_value;
+        tb = tstate->exc_traceback;
+        Py_XINCREF(type);
+        Py_XINCREF(value);
+        Py_XINCREF(tb);
+    }
+
+    /* We support the following forms of raise:
+       raise <class>, <classinstance>
+       raise <class>, <argument tuple>
+       raise <class>, None
+       raise <class>, <argument>
+       raise <classinstance>, None
+       raise <string>, <object>
+       raise <string>, None
+
+       An omitted second argument is the same as None.
+
+       In addition, raise <tuple>, <anything> is the same as
+       raising the tuple's first item (and it better have one!);
+       this rule is applied recursively.
+
+       Finally, an optional third argument can be supplied, which
+       gives the traceback to be substituted (useful when
+       re-raising an exception after examining it).  */
+
+    /* First, check the traceback argument, replacing None with
+       NULL. */
+    if (tb == Py_None) {
+        Py_DECREF(tb);
+        tb = NULL;
+    }
+    else if (tb != NULL && !PyTraceBack_Check(tb)) {
+        PyErr_SetString(PyExc_TypeError,
+                   "raise: arg 3 must be a traceback or None");
+        goto raise_error;
+    }
+
+    /* Next, replace a missing value with None */
+    if (value == NULL) {
+        value = Py_None;
+        Py_INCREF(value);
+    }
+
+    /* Next, repeatedly, replace a tuple exception with its first item */
+    while (PyTuple_Check(type) && PyTuple_Size(type) > 0) {
+        PyObject *tmp = type;
+        type = PyTuple_GET_ITEM(type, 0);
+        Py_INCREF(type);
+        Py_DECREF(tmp);
+    }
+
+    if (PyExceptionClass_Check(type))
+        PyErr_NormalizeException(&type, &value, &tb);
+
+    else if (PyExceptionInstance_Check(type)) {
+        /* Raising an instance.  The value should be a dummy. */
+        if (value != Py_None) {
+            PyErr_SetString(PyExc_TypeError,
+              "instance exception may not have a separate value");
+            goto raise_error;
+        }
+        else {
+            /* Normalize to raise <class>, <instance> */
+            Py_DECREF(value);
+            value = type;
+            type = PyExceptionInstance_Class(type);
+            Py_INCREF(type);
+        }
+    }
+    else {
+        /* Not something you can raise.  You get an exception
+           anyway, just not what you specified :-) */
+        PyErr_Format(PyExc_TypeError,
+                     "exceptions must be old-style classes or "
+                     "derived from BaseException, not %s",
+                     type->ob_type->tp_name);
+        goto raise_error;
+    }
+
+    assert(PyExceptionClass_Check(type));
+    if (Py_Py3kWarningFlag && PyClass_Check(type)) {
+        if (PyErr_WarnEx(PyExc_DeprecationWarning,
+                        "exceptions must derive from BaseException "
+                        "in 3.x", 1) < 0)
+            goto raise_error;
+    }
+
+    PyErr_Restore(type, value, tb);
+    if (tb == NULL)
+        return WHY_EXCEPTION;
+    else
+        return WHY_RERAISE;
  raise_error:
-	Py_XDECREF(value);
-	Py_XDECREF(type);
-	Py_XDECREF(tb);
-	return WHY_EXCEPTION;
+    Py_XDECREF(value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+    return WHY_EXCEPTION;
 }
 
 /* Iterate v argcnt times and store the results on the stack (via decreasing
@@ -3568,46 +3568,46 @@ do_raise(PyObject *type, PyObject *value, PyObject *tb)
 static int
 unpack_iterable(PyObject *v, int argcnt, PyObject **sp)
 {
-	int i = 0;
-	PyObject *it;  /* iter(v) */
-	PyObject *w;
-
-	assert(v != NULL);
-
-	it = PyObject_GetIter(v);
-	if (it == NULL)
-		goto Error;
-
-	for (; i < argcnt; i++) {
-		w = PyIter_Next(it);
-		if (w == NULL) {
-			/* Iterator done, via error or exhaustion. */
-			if (!PyErr_Occurred()) {
-				PyErr_Format(PyExc_ValueError,
-					"need more than %d value%s to unpack",
-					i, i == 1 ? "" : "s");
-			}
-			goto Error;
-		}
-		*--sp = w;
-	}
-
-	/* We better have exhausted the iterator now. */
-	w = PyIter_Next(it);
-	if (w == NULL) {
-		if (PyErr_Occurred())
-			goto Error;
-		Py_DECREF(it);
-		return 1;
-	}
-	Py_DECREF(w);
-	PyErr_SetString(PyExc_ValueError, "too many values to unpack");
-	/* fall through */
+    int i = 0;
+    PyObject *it;  /* iter(v) */
+    PyObject *w;
+
+    assert(v != NULL);
+
+    it = PyObject_GetIter(v);
+    if (it == NULL)
+        goto Error;
+
+    for (; i < argcnt; i++) {
+        w = PyIter_Next(it);
+        if (w == NULL) {
+            /* Iterator done, via error or exhaustion. */
+            if (!PyErr_Occurred()) {
+                PyErr_Format(PyExc_ValueError,
+                    "need more than %d value%s to unpack",
+                    i, i == 1 ? "" : "s");
+            }
+            goto Error;
+        }
+        *--sp = w;
+    }
+
+    /* We better have exhausted the iterator now. */
+    w = PyIter_Next(it);
+    if (w == NULL) {
+        if (PyErr_Occurred())
+            goto Error;
+        Py_DECREF(it);
+        return 1;
+    }
+    Py_DECREF(w);
+    PyErr_SetString(PyExc_ValueError, "too many values to unpack");
+    /* fall through */
 Error:
-	for (; i > 0; i--, sp++)
-		Py_DECREF(*sp);
-	Py_XDECREF(it);
-	return 0;
+    for (; i > 0; i--, sp++)
+        Py_DECREF(*sp);
+    Py_XDECREF(it);
+    return 0;
 }
 
 
@@ -3615,238 +3615,238 @@ Error:
 static int
 prtrace(PyObject *v, char *str)
 {
-	printf("%s ", str);
-	if (PyObject_Print(v, stdout, 0) != 0)
-		PyErr_Clear(); /* Don't know what else to do */
-	printf("\n");
-	return 1;
+    printf("%s ", str);
+    if (PyObject_Print(v, stdout, 0) != 0)
+        PyErr_Clear(); /* Don't know what else to do */
+    printf("\n");
+    return 1;
 }
 #endif
 
 static void
 call_exc_trace(Py_tracefunc func, PyObject *self, PyFrameObject *f)
 {
-	PyObject *type, *value, *traceback, *arg;
-	int err;
-	PyErr_Fetch(&type, &value, &traceback);
-	if (value == NULL) {
-		value = Py_None;
-		Py_INCREF(value);
-	}
-	arg = PyTuple_Pack(3, type, value, traceback);
-	if (arg == NULL) {
-		PyErr_Restore(type, value, traceback);
-		return;
-	}
-	err = call_trace(func, self, f, PyTrace_EXCEPTION, arg);
-	Py_DECREF(arg);
-	if (err == 0)
-		PyErr_Restore(type, value, traceback);
-	else {
-		Py_XDECREF(type);
-		Py_XDECREF(value);
-		Py_XDECREF(traceback);
-	}
+    PyObject *type, *value, *traceback, *arg;
+    int err;
+    PyErr_Fetch(&type, &value, &traceback);
+    if (value == NULL) {
+        value = Py_None;
+        Py_INCREF(value);
+    }
+    arg = PyTuple_Pack(3, type, value, traceback);
+    if (arg == NULL) {
+        PyErr_Restore(type, value, traceback);
+        return;
+    }
+    err = call_trace(func, self, f, PyTrace_EXCEPTION, arg);
+    Py_DECREF(arg);
+    if (err == 0)
+        PyErr_Restore(type, value, traceback);
+    else {
+        Py_XDECREF(type);
+        Py_XDECREF(value);
+        Py_XDECREF(traceback);
+    }
 }
 
 static int
 call_trace_protected(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
-		     int what, PyObject *arg)
+                     int what, PyObject *arg)
 {
-	PyObject *type, *value, *traceback;
-	int err;
-	PyErr_Fetch(&type, &value, &traceback);
-	err = call_trace(func, obj, frame, what, arg);
-	if (err == 0)
-	{
-		PyErr_Restore(type, value, traceback);
-		return 0;
-	}
-	else {
-		Py_XDECREF(type);
-		Py_XDECREF(value);
-		Py_XDECREF(traceback);
-		return -1;
-	}
+    PyObject *type, *value, *traceback;
+    int err;
+    PyErr_Fetch(&type, &value, &traceback);
+    err = call_trace(func, obj, frame, what, arg);
+    if (err == 0)
+    {
+        PyErr_Restore(type, value, traceback);
+        return 0;
+    }
+    else {
+        Py_XDECREF(type);
+        Py_XDECREF(value);
+        Py_XDECREF(traceback);
+        return -1;
+    }
 }
 
 static int
 call_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
-	   int what, PyObject *arg)
+           int what, PyObject *arg)
 {
-	register PyThreadState *tstate = frame->f_tstate;
-	int result;
-	if (tstate->tracing)
-		return 0;
-	tstate->tracing++;
-	tstate->use_tracing = 0;
-	result = func(obj, frame, what, arg);
-	tstate->use_tracing = ((tstate->c_tracefunc != NULL)
-			       || (tstate->c_profilefunc != NULL));
-	tstate->tracing--;
-	return result;
+    register PyThreadState *tstate = frame->f_tstate;
+    int result;
+    if (tstate->tracing)
+        return 0;
+    tstate->tracing++;
+    tstate->use_tracing = 0;
+    result = func(obj, frame, what, arg);
+    tstate->use_tracing = ((tstate->c_tracefunc != NULL)
+                           || (tstate->c_profilefunc != NULL));
+    tstate->tracing--;
+    return result;
 }
 
 PyObject *
 _PyEval_CallTracing(PyObject *func, PyObject *args)
 {
-	PyFrameObject *frame = PyEval_GetFrame();
-	PyThreadState *tstate = frame->f_tstate;
-	int save_tracing = tstate->tracing;
-	int save_use_tracing = tstate->use_tracing;
-	PyObject *result;
-
-	tstate->tracing = 0;
-	tstate->use_tracing = ((tstate->c_tracefunc != NULL)
-			       || (tstate->c_profilefunc != NULL));
-	result = PyObject_Call(func, args, NULL);
-	tstate->tracing = save_tracing;
-	tstate->use_tracing = save_use_tracing;
-	return result;
+    PyFrameObject *frame = PyEval_GetFrame();
+    PyThreadState *tstate = frame->f_tstate;
+    int save_tracing = tstate->tracing;
+    int save_use_tracing = tstate->use_tracing;
+    PyObject *result;
+
+    tstate->tracing = 0;
+    tstate->use_tracing = ((tstate->c_tracefunc != NULL)
+                           || (tstate->c_profilefunc != NULL));
+    result = PyObject_Call(func, args, NULL);
+    tstate->tracing = save_tracing;
+    tstate->use_tracing = save_use_tracing;
+    return result;
 }
 
 /* See Objects/lnotab_notes.txt for a description of how tracing works. */
 static int
 maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
-		      PyFrameObject *frame, int *instr_lb, int *instr_ub,
-		      int *instr_prev)
+                      PyFrameObject *frame, int *instr_lb, int *instr_ub,
+                      int *instr_prev)
 {
-	int result = 0;
-	int line = frame->f_lineno;
-
-        /* If the last instruction executed isn't in the current
-           instruction window, reset the window.
-        */
-	if (frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub) {
-		PyAddrPair bounds;
-		line = _PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
-					       &bounds);
-		*instr_lb = bounds.ap_lower;
-		*instr_ub = bounds.ap_upper;
-	}
-	/* If the last instruction falls at the start of a line or if
-           it represents a jump backwards, update the frame's line
-           number and call the trace function. */
-	if (frame->f_lasti == *instr_lb || frame->f_lasti < *instr_prev) {
-		frame->f_lineno = line;
-		result = call_trace(func, obj, frame, PyTrace_LINE, Py_None);
-	}
-	*instr_prev = frame->f_lasti;
-	return result;
+    int result = 0;
+    int line = frame->f_lineno;
+
+    /* If the last instruction executed isn't in the current
+       instruction window, reset the window.
+    */
+    if (frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub) {
+        PyAddrPair bounds;
+        line = _PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
+                                       &bounds);
+        *instr_lb = bounds.ap_lower;
+        *instr_ub = bounds.ap_upper;
+    }
+    /* If the last instruction falls at the start of a line or if
+       it represents a jump backwards, update the frame's line
+       number and call the trace function. */
+    if (frame->f_lasti == *instr_lb || frame->f_lasti < *instr_prev) {
+        frame->f_lineno = line;
+        result = call_trace(func, obj, frame, PyTrace_LINE, Py_None);
+    }
+    *instr_prev = frame->f_lasti;
+    return result;
 }
 
 void
 PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
 {
-	PyThreadState *tstate = PyThreadState_GET();
-	PyObject *temp = tstate->c_profileobj;
-	Py_XINCREF(arg);
-	tstate->c_profilefunc = NULL;
-	tstate->c_profileobj = NULL;
-	/* Must make sure that tracing is not ignored if 'temp' is freed */
-	tstate->use_tracing = tstate->c_tracefunc != NULL;
-	Py_XDECREF(temp);
-	tstate->c_profilefunc = func;
-	tstate->c_profileobj = arg;
-	/* Flag that tracing or profiling is turned on */
-	tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *temp = tstate->c_profileobj;
+    Py_XINCREF(arg);
+    tstate->c_profilefunc = NULL;
+    tstate->c_profileobj = NULL;
+    /* Must make sure that tracing is not ignored if 'temp' is freed */
+    tstate->use_tracing = tstate->c_tracefunc != NULL;
+    Py_XDECREF(temp);
+    tstate->c_profilefunc = func;
+    tstate->c_profileobj = arg;
+    /* Flag that tracing or profiling is turned on */
+    tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
 }
 
 void
 PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
 {
-	PyThreadState *tstate = PyThreadState_GET();
-	PyObject *temp = tstate->c_traceobj;
-	_Py_TracingPossible += (func != NULL) - (tstate->c_tracefunc != NULL);
-	Py_XINCREF(arg);
-	tstate->c_tracefunc = NULL;
-	tstate->c_traceobj = NULL;
-	/* Must make sure that profiling is not ignored if 'temp' is freed */
-	tstate->use_tracing = tstate->c_profilefunc != NULL;
-	Py_XDECREF(temp);
-	tstate->c_tracefunc = func;
-	tstate->c_traceobj = arg;
-	/* Flag that tracing or profiling is turned on */
-	tstate->use_tracing = ((func != NULL)
-			       || (tstate->c_profilefunc != NULL));
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *temp = tstate->c_traceobj;
+    _Py_TracingPossible += (func != NULL) - (tstate->c_tracefunc != NULL);
+    Py_XINCREF(arg);
+    tstate->c_tracefunc = NULL;
+    tstate->c_traceobj = NULL;
+    /* Must make sure that profiling is not ignored if 'temp' is freed */
+    tstate->use_tracing = tstate->c_profilefunc != NULL;
+    Py_XDECREF(temp);
+    tstate->c_tracefunc = func;
+    tstate->c_traceobj = arg;
+    /* Flag that tracing or profiling is turned on */
+    tstate->use_tracing = ((func != NULL)
+                           || (tstate->c_profilefunc != NULL));
 }
 
 PyObject *
 PyEval_GetBuiltins(void)
 {
-	PyFrameObject *current_frame = PyEval_GetFrame();
-	if (current_frame == NULL)
-		return PyThreadState_GET()->interp->builtins;
-	else
-		return current_frame->f_builtins;
+    PyFrameObject *current_frame = PyEval_GetFrame();
+    if (current_frame == NULL)
+        return PyThreadState_GET()->interp->builtins;
+    else
+        return current_frame->f_builtins;
 }
 
 PyObject *
 PyEval_GetLocals(void)
 {
-	PyFrameObject *current_frame = PyEval_GetFrame();
-	if (current_frame == NULL)
-		return NULL;
-	PyFrame_FastToLocals(current_frame);
-	return current_frame->f_locals;
+    PyFrameObject *current_frame = PyEval_GetFrame();
+    if (current_frame == NULL)
+        return NULL;
+    PyFrame_FastToLocals(current_frame);
+    return current_frame->f_locals;
 }
 
 PyObject *
 PyEval_GetGlobals(void)
 {
-	PyFrameObject *current_frame = PyEval_GetFrame();
-	if (current_frame == NULL)
-		return NULL;
-	else
-		return current_frame->f_globals;
+    PyFrameObject *current_frame = PyEval_GetFrame();
+    if (current_frame == NULL)
+        return NULL;
+    else
+        return current_frame->f_globals;
 }
 
 PyFrameObject *
 PyEval_GetFrame(void)
 {
-	PyThreadState *tstate = PyThreadState_GET();
-	return _PyThreadState_GetFrame(tstate);
+    PyThreadState *tstate = PyThreadState_GET();
+    return _PyThreadState_GetFrame(tstate);
 }
 
 int
 PyEval_GetRestricted(void)
 {
-	PyFrameObject *current_frame = PyEval_GetFrame();
-	return current_frame == NULL ? 0 : PyFrame_IsRestricted(current_frame);
+    PyFrameObject *current_frame = PyEval_GetFrame();
+    return current_frame == NULL ? 0 : PyFrame_IsRestricted(current_frame);
 }
 
 int
 PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
 {
-	PyFrameObject *current_frame = PyEval_GetFrame();
-	int result = cf->cf_flags != 0;
-
-	if (current_frame != NULL) {
-		const int codeflags = current_frame->f_code->co_flags;
-		const int compilerflags = codeflags & PyCF_MASK;
-		if (compilerflags) {
-			result = 1;
-			cf->cf_flags |= compilerflags;
-		}
+    PyFrameObject *current_frame = PyEval_GetFrame();
+    int result = cf->cf_flags != 0;
+
+    if (current_frame != NULL) {
+        const int codeflags = current_frame->f_code->co_flags;
+        const int compilerflags = codeflags & PyCF_MASK;
+        if (compilerflags) {
+            result = 1;
+            cf->cf_flags |= compilerflags;
+        }
 #if 0 /* future keyword */
-		if (codeflags & CO_GENERATOR_ALLOWED) {
-			result = 1;
-			cf->cf_flags |= CO_GENERATOR_ALLOWED;
-		}
+        if (codeflags & CO_GENERATOR_ALLOWED) {
+            result = 1;
+            cf->cf_flags |= CO_GENERATOR_ALLOWED;
+        }
 #endif
-	}
-	return result;
+    }
+    return result;
 }
 
 int
 Py_FlushLine(void)
 {
-	PyObject *f = PySys_GetObject("stdout");
-	if (f == NULL)
-		return 0;
-	if (!PyFile_SoftSpace(f, 0))
-		return 0;
-	return PyFile_WriteString("\n", f);
+    PyObject *f = PySys_GetObject("stdout");
+    if (f == NULL)
+        return 0;
+    if (!PyFile_SoftSpace(f, 0))
+        return 0;
+    return PyFile_WriteString("\n", f);
 }
 
 
@@ -3856,197 +3856,197 @@ Py_FlushLine(void)
 PyObject *
 PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw)
 {
-	PyObject *result;
-
-	if (arg == NULL) {
-		arg = PyTuple_New(0);
-		if (arg == NULL)
-			return NULL;
-	}
-	else if (!PyTuple_Check(arg)) {
-		PyErr_SetString(PyExc_TypeError,
-				"argument list must be a tuple");
-		return NULL;
-	}
-	else
-		Py_INCREF(arg);
-
-	if (kw != NULL && !PyDict_Check(kw)) {
-		PyErr_SetString(PyExc_TypeError,
-				"keyword list must be a dictionary");
-		Py_DECREF(arg);
-		return NULL;
-	}
-
-	result = PyObject_Call(func, arg, kw);
-	Py_DECREF(arg);
-	return result;
+    PyObject *result;
+
+    if (arg == NULL) {
+        arg = PyTuple_New(0);
+        if (arg == NULL)
+            return NULL;
+    }
+    else if (!PyTuple_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "argument list must be a tuple");
+        return NULL;
+    }
+    else
+        Py_INCREF(arg);
+
+    if (kw != NULL && !PyDict_Check(kw)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "keyword list must be a dictionary");
+        Py_DECREF(arg);
+        return NULL;
+    }
+
+    result = PyObject_Call(func, arg, kw);
+    Py_DECREF(arg);
+    return result;
 }
 
 const char *
 PyEval_GetFuncName(PyObject *func)
 {
-	if (PyMethod_Check(func))
-		return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
-	else if (PyFunction_Check(func))
-		return PyString_AsString(((PyFunctionObject*)func)->func_name);
-	else if (PyCFunction_Check(func))
-		return ((PyCFunctionObject*)func)->m_ml->ml_name;
-	else if (PyClass_Check(func))
-		return PyString_AsString(((PyClassObject*)func)->cl_name);
-	else if (PyInstance_Check(func)) {
-		return PyString_AsString(
-			((PyInstanceObject*)func)->in_class->cl_name);
-	} else {
-		return func->ob_type->tp_name;
-	}
+    if (PyMethod_Check(func))
+        return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
+    else if (PyFunction_Check(func))
+        return PyString_AsString(((PyFunctionObject*)func)->func_name);
+    else if (PyCFunction_Check(func))
+        return ((PyCFunctionObject*)func)->m_ml->ml_name;
+    else if (PyClass_Check(func))
+        return PyString_AsString(((PyClassObject*)func)->cl_name);
+    else if (PyInstance_Check(func)) {
+        return PyString_AsString(
+            ((PyInstanceObject*)func)->in_class->cl_name);
+    } else {
+        return func->ob_type->tp_name;
+    }
 }
 
 const char *
 PyEval_GetFuncDesc(PyObject *func)
 {
-	if (PyMethod_Check(func))
-		return "()";
-	else if (PyFunction_Check(func))
-		return "()";
-	else if (PyCFunction_Check(func))
-		return "()";
-	else if (PyClass_Check(func))
-		return " constructor";
-	else if (PyInstance_Check(func)) {
-		return " instance";
-	} else {
-		return " object";
-	}
+    if (PyMethod_Check(func))
+        return "()";
+    else if (PyFunction_Check(func))
+        return "()";
+    else if (PyCFunction_Check(func))
+        return "()";
+    else if (PyClass_Check(func))
+        return " constructor";
+    else if (PyInstance_Check(func)) {
+        return " instance";
+    } else {
+        return " object";
+    }
 }
 
 static void
 err_args(PyObject *func, int flags, int nargs)
 {
-	if (flags & METH_NOARGS)
-		PyErr_Format(PyExc_TypeError,
-			     "%.200s() takes no arguments (%d given)",
-			     ((PyCFunctionObject *)func)->m_ml->ml_name,
-			     nargs);
-	else
-		PyErr_Format(PyExc_TypeError,
-			     "%.200s() takes exactly one argument (%d given)",
-			     ((PyCFunctionObject *)func)->m_ml->ml_name,
-			     nargs);
+    if (flags & METH_NOARGS)
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no arguments (%d given)",
+                     ((PyCFunctionObject *)func)->m_ml->ml_name,
+                     nargs);
+    else
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes exactly one argument (%d given)",
+                     ((PyCFunctionObject *)func)->m_ml->ml_name,
+                     nargs);
 }
 
 #define C_TRACE(x, call) \
 if (tstate->use_tracing && tstate->c_profilefunc) { \
-	if (call_trace(tstate->c_profilefunc, \
-		tstate->c_profileobj, \
-		tstate->frame, PyTrace_C_CALL, \
-		func)) { \
-		x = NULL; \
-	} \
-	else { \
-		x = call; \
-		if (tstate->c_profilefunc != NULL) { \
-			if (x == NULL) { \
-				call_trace_protected(tstate->c_profilefunc, \
-					tstate->c_profileobj, \
-					tstate->frame, PyTrace_C_EXCEPTION, \
-					func); \
-				/* XXX should pass (type, value, tb) */ \
-			} else { \
-				if (call_trace(tstate->c_profilefunc, \
-					tstate->c_profileobj, \
-					tstate->frame, PyTrace_C_RETURN, \
-					func)) { \
-					Py_DECREF(x); \
-					x = NULL; \
-				} \
-			} \
-		} \
-	} \
+    if (call_trace(tstate->c_profilefunc, \
+        tstate->c_profileobj, \
+        tstate->frame, PyTrace_C_CALL, \
+        func)) { \
+        x = NULL; \
+    } \
+    else { \
+        x = call; \
+        if (tstate->c_profilefunc != NULL) { \
+            if (x == NULL) { \
+                call_trace_protected(tstate->c_profilefunc, \
+                    tstate->c_profileobj, \
+                    tstate->frame, PyTrace_C_EXCEPTION, \
+                    func); \
+                /* XXX should pass (type, value, tb) */ \
+            } else { \
+                if (call_trace(tstate->c_profilefunc, \
+                    tstate->c_profileobj, \
+                    tstate->frame, PyTrace_C_RETURN, \
+                    func)) { \
+                    Py_DECREF(x); \
+                    x = NULL; \
+                } \
+            } \
+        } \
+    } \
 } else { \
-	x = call; \
-	}
+    x = call; \
+    }
 
 static PyObject *
 call_function(PyObject ***pp_stack, int oparg
 #ifdef WITH_TSC
-		, uint64* pintr0, uint64* pintr1
+                , uint64* pintr0, uint64* pintr1
 #endif
-		)
+                )
 {
-	int na = oparg & 0xff;
-	int nk = (oparg>>8) & 0xff;
-	int n = na + 2 * nk;
-	PyObject **pfunc = (*pp_stack) - n - 1;
-	PyObject *func = *pfunc;
-	PyObject *x, *w;
-
-	/* Always dispatch PyCFunction first, because these are
-	   presumed to be the most frequent callable object.
-	*/
-	if (PyCFunction_Check(func) && nk == 0) {
-		int flags = PyCFunction_GET_FLAGS(func);
-		PyThreadState *tstate = PyThreadState_GET();
-
-		PCALL(PCALL_CFUNCTION);
-		if (flags & (METH_NOARGS | METH_O)) {
-			PyCFunction meth = PyCFunction_GET_FUNCTION(func);
-			PyObject *self = PyCFunction_GET_SELF(func);
-			if (flags & METH_NOARGS && na == 0) {
-				C_TRACE(x, (*meth)(self,NULL));
-			}
-			else if (flags & METH_O && na == 1) {
-				PyObject *arg = EXT_POP(*pp_stack);
-				C_TRACE(x, (*meth)(self,arg));
-				Py_DECREF(arg);
-			}
-			else {
-				err_args(func, flags, na);
-				x = NULL;
-			}
-		}
-		else {
-			PyObject *callargs;
-			callargs = load_args(pp_stack, na);
-			READ_TIMESTAMP(*pintr0);
-			C_TRACE(x, PyCFunction_Call(func,callargs,NULL));
-			READ_TIMESTAMP(*pintr1);
-			Py_XDECREF(callargs);
-		}
-	} else {
-		if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
-			/* optimize access to bound methods */
-			PyObject *self = PyMethod_GET_SELF(func);
-			PCALL(PCALL_METHOD);
-			PCALL(PCALL_BOUND_METHOD);
-			Py_INCREF(self);
-			func = PyMethod_GET_FUNCTION(func);
-			Py_INCREF(func);
-			Py_DECREF(*pfunc);
-			*pfunc = self;
-			na++;
-			n++;
-		} else
-			Py_INCREF(func);
-		READ_TIMESTAMP(*pintr0);
-		if (PyFunction_Check(func))
-			x = fast_function(func, pp_stack, n, na, nk);
-		else
-			x = do_call(func, pp_stack, na, nk);
-		READ_TIMESTAMP(*pintr1);
-		Py_DECREF(func);
-	}
-
-	/* Clear the stack of the function object.  Also removes
-           the arguments in case they weren't consumed already
-           (fast_function() and err_args() leave them on the stack).
-	 */
-	while ((*pp_stack) > pfunc) {
-		w = EXT_POP(*pp_stack);
-		Py_DECREF(w);
-		PCALL(PCALL_POP);
-	}
-	return x;
+    int na = oparg & 0xff;
+    int nk = (oparg>>8) & 0xff;
+    int n = na + 2 * nk;
+    PyObject **pfunc = (*pp_stack) - n - 1;
+    PyObject *func = *pfunc;
+    PyObject *x, *w;
+
+    /* Always dispatch PyCFunction first, because these are
+       presumed to be the most frequent callable object.
+    */
+    if (PyCFunction_Check(func) && nk == 0) {
+        int flags = PyCFunction_GET_FLAGS(func);
+        PyThreadState *tstate = PyThreadState_GET();
+
+        PCALL(PCALL_CFUNCTION);
+        if (flags & (METH_NOARGS | METH_O)) {
+            PyCFunction meth = PyCFunction_GET_FUNCTION(func);
+            PyObject *self = PyCFunction_GET_SELF(func);
+            if (flags & METH_NOARGS && na == 0) {
+                C_TRACE(x, (*meth)(self,NULL));
+            }
+            else if (flags & METH_O && na == 1) {
+                PyObject *arg = EXT_POP(*pp_stack);
+                C_TRACE(x, (*meth)(self,arg));
+                Py_DECREF(arg);
+            }
+            else {
+                err_args(func, flags, na);
+                x = NULL;
+            }
+        }
+        else {
+            PyObject *callargs;
+            callargs = load_args(pp_stack, na);
+            READ_TIMESTAMP(*pintr0);
+            C_TRACE(x, PyCFunction_Call(func,callargs,NULL));
+            READ_TIMESTAMP(*pintr1);
+            Py_XDECREF(callargs);
+        }
+    } else {
+        if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
+            /* optimize access to bound methods */
+            PyObject *self = PyMethod_GET_SELF(func);
+            PCALL(PCALL_METHOD);
+            PCALL(PCALL_BOUND_METHOD);
+            Py_INCREF(self);
+            func = PyMethod_GET_FUNCTION(func);
+            Py_INCREF(func);
+            Py_DECREF(*pfunc);
+            *pfunc = self;
+            na++;
+            n++;
+        } else
+            Py_INCREF(func);
+        READ_TIMESTAMP(*pintr0);
+        if (PyFunction_Check(func))
+            x = fast_function(func, pp_stack, n, na, nk);
+        else
+            x = do_call(func, pp_stack, na, nk);
+        READ_TIMESTAMP(*pintr1);
+        Py_DECREF(func);
+    }
+
+    /* Clear the stack of the function object.  Also removes
+       the arguments in case they weren't consumed already
+       (fast_function() and err_args() leave them on the stack).
+     */
+    while ((*pp_stack) > pfunc) {
+        w = EXT_POP(*pp_stack);
+        Py_DECREF(w);
+        PCALL(PCALL_POP);
+    }
+    return x;
 }
 
 /* The fast_function() function optimize calls for which no argument
@@ -4061,273 +4061,273 @@ call_function(PyObject ***pp_stack, int oparg
 static PyObject *
 fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
 {
-	PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
-	PyObject *globals = PyFunction_GET_GLOBALS(func);
-	PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
-	PyObject **d = NULL;
-	int nd = 0;
-
-	PCALL(PCALL_FUNCTION);
-	PCALL(PCALL_FAST_FUNCTION);
-	if (argdefs == NULL && co->co_argcount == n && nk==0 &&
-	    co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
-		PyFrameObject *f;
-		PyObject *retval = NULL;
-		PyThreadState *tstate = PyThreadState_GET();
-		PyObject **fastlocals, **stack;
-		int i;
-
-		PCALL(PCALL_FASTER_FUNCTION);
-		assert(globals != NULL);
-		/* XXX Perhaps we should create a specialized
-		   PyFrame_New() that doesn't take locals, but does
-		   take builtins without sanity checking them.
-		*/
-		assert(tstate != NULL);
-		f = PyFrame_New(tstate, co, globals, NULL);
-		if (f == NULL)
-			return NULL;
-
-		fastlocals = f->f_localsplus;
-		stack = (*pp_stack) - n;
-
-		for (i = 0; i < n; i++) {
-			Py_INCREF(*stack);
-			fastlocals[i] = *stack++;
-		}
-		retval = PyEval_EvalFrameEx(f,0);
-		++tstate->recursion_depth;
-		Py_DECREF(f);
-		--tstate->recursion_depth;
-		return retval;
-	}
-	if (argdefs != NULL) {
-		d = &PyTuple_GET_ITEM(argdefs, 0);
-		nd = Py_SIZE(argdefs);
-	}
-	return PyEval_EvalCodeEx(co, globals,
-				 (PyObject *)NULL, (*pp_stack)-n, na,
-				 (*pp_stack)-2*nk, nk, d, nd,
-				 PyFunction_GET_CLOSURE(func));
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject **d = NULL;
+    int nd = 0;
+
+    PCALL(PCALL_FUNCTION);
+    PCALL(PCALL_FAST_FUNCTION);
+    if (argdefs == NULL && co->co_argcount == n && nk==0 &&
+        co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        PyFrameObject *f;
+        PyObject *retval = NULL;
+        PyThreadState *tstate = PyThreadState_GET();
+        PyObject **fastlocals, **stack;
+        int i;
+
+        PCALL(PCALL_FASTER_FUNCTION);
+        assert(globals != NULL);
+        /* XXX Perhaps we should create a specialized
+           PyFrame_New() that doesn't take locals, but does
+           take builtins without sanity checking them.
+        */
+        assert(tstate != NULL);
+        f = PyFrame_New(tstate, co, globals, NULL);
+        if (f == NULL)
+            return NULL;
+
+        fastlocals = f->f_localsplus;
+        stack = (*pp_stack) - n;
+
+        for (i = 0; i < n; i++) {
+            Py_INCREF(*stack);
+            fastlocals[i] = *stack++;
+        }
+        retval = PyEval_EvalFrameEx(f,0);
+        ++tstate->recursion_depth;
+        Py_DECREF(f);
+        --tstate->recursion_depth;
+        return retval;
+    }
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
+    }
+    return PyEval_EvalCodeEx(co, globals,
+                             (PyObject *)NULL, (*pp_stack)-n, na,
+                             (*pp_stack)-2*nk, nk, d, nd,
+                             PyFunction_GET_CLOSURE(func));
 }
 
 static PyObject *
 update_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack,
                     PyObject *func)
 {
-	PyObject *kwdict = NULL;
-	if (orig_kwdict == NULL)
-		kwdict = PyDict_New();
-	else {
-		kwdict = PyDict_Copy(orig_kwdict);
-		Py_DECREF(orig_kwdict);
-	}
-	if (kwdict == NULL)
-		return NULL;
-	while (--nk >= 0) {
-		int err;
-		PyObject *value = EXT_POP(*pp_stack);
-		PyObject *key = EXT_POP(*pp_stack);
-		if (PyDict_GetItem(kwdict, key) != NULL) {
-			PyErr_Format(PyExc_TypeError,
-				     "%.200s%s got multiple values "
-				     "for keyword argument '%.200s'",
-				     PyEval_GetFuncName(func),
-				     PyEval_GetFuncDesc(func),
-				     PyString_AsString(key));
-			Py_DECREF(key);
-			Py_DECREF(value);
-			Py_DECREF(kwdict);
-			return NULL;
-		}
-		err = PyDict_SetItem(kwdict, key, value);
-		Py_DECREF(key);
-		Py_DECREF(value);
-		if (err) {
-			Py_DECREF(kwdict);
-			return NULL;
-		}
-	}
-	return kwdict;
+    PyObject *kwdict = NULL;
+    if (orig_kwdict == NULL)
+        kwdict = PyDict_New();
+    else {
+        kwdict = PyDict_Copy(orig_kwdict);
+        Py_DECREF(orig_kwdict);
+    }
+    if (kwdict == NULL)
+        return NULL;
+    while (--nk >= 0) {
+        int err;
+        PyObject *value = EXT_POP(*pp_stack);
+        PyObject *key = EXT_POP(*pp_stack);
+        if (PyDict_GetItem(kwdict, key) != NULL) {
+            PyErr_Format(PyExc_TypeError,
+                         "%.200s%s got multiple values "
+                         "for keyword argument '%.200s'",
+                         PyEval_GetFuncName(func),
+                         PyEval_GetFuncDesc(func),
+                         PyString_AsString(key));
+            Py_DECREF(key);
+            Py_DECREF(value);
+            Py_DECREF(kwdict);
+            return NULL;
+        }
+        err = PyDict_SetItem(kwdict, key, value);
+        Py_DECREF(key);
+        Py_DECREF(value);
+        if (err) {
+            Py_DECREF(kwdict);
+            return NULL;
+        }
+    }
+    return kwdict;
 }
 
 static PyObject *
 update_star_args(int nstack, int nstar, PyObject *stararg,
-		 PyObject ***pp_stack)
+                 PyObject ***pp_stack)
 {
-	PyObject *callargs, *w;
-
-	callargs = PyTuple_New(nstack + nstar);
-	if (callargs == NULL) {
-		return NULL;
-	}
-	if (nstar) {
-		int i;
-		for (i = 0; i < nstar; i++) {
-			PyObject *a = PyTuple_GET_ITEM(stararg, i);
-			Py_INCREF(a);
-			PyTuple_SET_ITEM(callargs, nstack + i, a);
-		}
-	}
-	while (--nstack >= 0) {
-		w = EXT_POP(*pp_stack);
-		PyTuple_SET_ITEM(callargs, nstack, w);
-	}
-	return callargs;
+    PyObject *callargs, *w;
+
+    callargs = PyTuple_New(nstack + nstar);
+    if (callargs == NULL) {
+        return NULL;
+    }
+    if (nstar) {
+        int i;
+        for (i = 0; i < nstar; i++) {
+            PyObject *a = PyTuple_GET_ITEM(stararg, i);
+            Py_INCREF(a);
+            PyTuple_SET_ITEM(callargs, nstack + i, a);
+        }
+    }
+    while (--nstack >= 0) {
+        w = EXT_POP(*pp_stack);
+        PyTuple_SET_ITEM(callargs, nstack, w);
+    }
+    return callargs;
 }
 
 static PyObject *
 load_args(PyObject ***pp_stack, int na)
 {
-	PyObject *args = PyTuple_New(na);
-	PyObject *w;
-
-	if (args == NULL)
-		return NULL;
-	while (--na >= 0) {
-		w = EXT_POP(*pp_stack);
-		PyTuple_SET_ITEM(args, na, w);
-	}
-	return args;
+    PyObject *args = PyTuple_New(na);
+    PyObject *w;
+
+    if (args == NULL)
+        return NULL;
+    while (--na >= 0) {
+        w = EXT_POP(*pp_stack);
+        PyTuple_SET_ITEM(args, na, w);
+    }
+    return args;
 }
 
 static PyObject *
 do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
 {
-	PyObject *callargs = NULL;
-	PyObject *kwdict = NULL;
-	PyObject *result = NULL;
-
-	if (nk > 0) {
-		kwdict = update_keyword_args(NULL, nk, pp_stack, func);
-		if (kwdict == NULL)
-			goto call_fail;
-	}
-	callargs = load_args(pp_stack, na);
-	if (callargs == NULL)
-		goto call_fail;
+    PyObject *callargs = NULL;
+    PyObject *kwdict = NULL;
+    PyObject *result = NULL;
+
+    if (nk > 0) {
+        kwdict = update_keyword_args(NULL, nk, pp_stack, func);
+        if (kwdict == NULL)
+            goto call_fail;
+    }
+    callargs = load_args(pp_stack, na);
+    if (callargs == NULL)
+        goto call_fail;
 #ifdef CALL_PROFILE
-	/* At this point, we have to look at the type of func to
-	   update the call stats properly.  Do it here so as to avoid
-	   exposing the call stats machinery outside ceval.c
-	*/
-	if (PyFunction_Check(func))
-		PCALL(PCALL_FUNCTION);
-	else if (PyMethod_Check(func))
-		PCALL(PCALL_METHOD);
-	else if (PyType_Check(func))
-		PCALL(PCALL_TYPE);
-	else if (PyCFunction_Check(func))
-		PCALL(PCALL_CFUNCTION);
-	else
-		PCALL(PCALL_OTHER);
+    /* At this point, we have to look at the type of func to
+       update the call stats properly.  Do it here so as to avoid
+       exposing the call stats machinery outside ceval.c
+    */
+    if (PyFunction_Check(func))
+        PCALL(PCALL_FUNCTION);
+    else if (PyMethod_Check(func))
+        PCALL(PCALL_METHOD);
+    else if (PyType_Check(func))
+        PCALL(PCALL_TYPE);
+    else if (PyCFunction_Check(func))
+        PCALL(PCALL_CFUNCTION);
+    else
+        PCALL(PCALL_OTHER);
 #endif
-	if (PyCFunction_Check(func)) {
-		PyThreadState *tstate = PyThreadState_GET();
-		C_TRACE(result, PyCFunction_Call(func, callargs, kwdict));
-	}
-	else
-		result = PyObject_Call(func, callargs, kwdict);
+    if (PyCFunction_Check(func)) {
+        PyThreadState *tstate = PyThreadState_GET();
+        C_TRACE(result, PyCFunction_Call(func, callargs, kwdict));
+    }
+    else
+        result = PyObject_Call(func, callargs, kwdict);
  call_fail:
-	Py_XDECREF(callargs);
-	Py_XDECREF(kwdict);
-	return result;
+    Py_XDECREF(callargs);
+    Py_XDECREF(kwdict);
+    return result;
 }
 
 static PyObject *
 ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
 {
-	int nstar = 0;
-	PyObject *callargs = NULL;
-	PyObject *stararg = NULL;
-	PyObject *kwdict = NULL;
-	PyObject *result = NULL;
-
-	if (flags & CALL_FLAG_KW) {
-		kwdict = EXT_POP(*pp_stack);
-		if (!PyDict_Check(kwdict)) {
-			PyObject *d;
-			d = PyDict_New();
-			if (d == NULL)
-				goto ext_call_fail;
-			if (PyDict_Update(d, kwdict) != 0) {
-				Py_DECREF(d);
-				/* PyDict_Update raises attribute
-				 * error (percolated from an attempt
-				 * to get 'keys' attribute) instead of
-				 * a type error if its second argument
-				 * is not a mapping.
-				 */
-				if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
-					PyErr_Format(PyExc_TypeError,
-						     "%.200s%.200s argument after ** "
-						     "must be a mapping, not %.200s",
-						     PyEval_GetFuncName(func),
-						     PyEval_GetFuncDesc(func),
-						     kwdict->ob_type->tp_name);
-				}
-				goto ext_call_fail;
-			}
-			Py_DECREF(kwdict);
-			kwdict = d;
-		}
-	}
-	if (flags & CALL_FLAG_VAR) {
-		stararg = EXT_POP(*pp_stack);
-		if (!PyTuple_Check(stararg)) {
-			PyObject *t = NULL;
-			t = PySequence_Tuple(stararg);
-			if (t == NULL) {
-				if (PyErr_ExceptionMatches(PyExc_TypeError)) {
-					PyErr_Format(PyExc_TypeError,
-						     "%.200s%.200s argument after * "
-						     "must be a sequence, not %200s",
-						     PyEval_GetFuncName(func),
-						     PyEval_GetFuncDesc(func),
-						     stararg->ob_type->tp_name);
-				}
-				goto ext_call_fail;
-			}
-			Py_DECREF(stararg);
-			stararg = t;
-		}
-		nstar = PyTuple_GET_SIZE(stararg);
-	}
-	if (nk > 0) {
-		kwdict = update_keyword_args(kwdict, nk, pp_stack, func);
-		if (kwdict == NULL)
-			goto ext_call_fail;
-	}
-	callargs = update_star_args(na, nstar, stararg, pp_stack);
-	if (callargs == NULL)
-		goto ext_call_fail;
+    int nstar = 0;
+    PyObject *callargs = NULL;
+    PyObject *stararg = NULL;
+    PyObject *kwdict = NULL;
+    PyObject *result = NULL;
+
+    if (flags & CALL_FLAG_KW) {
+        kwdict = EXT_POP(*pp_stack);
+        if (!PyDict_Check(kwdict)) {
+            PyObject *d;
+            d = PyDict_New();
+            if (d == NULL)
+                goto ext_call_fail;
+            if (PyDict_Update(d, kwdict) != 0) {
+                Py_DECREF(d);
+                /* PyDict_Update raises attribute
+                 * error (percolated from an attempt
+                 * to get 'keys' attribute) instead of
+                 * a type error if its second argument
+                 * is not a mapping.
+                 */
+                if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+                    PyErr_Format(PyExc_TypeError,
+                                 "%.200s%.200s argument after ** "
+                                 "must be a mapping, not %.200s",
+                                 PyEval_GetFuncName(func),
+                                 PyEval_GetFuncDesc(func),
+                                 kwdict->ob_type->tp_name);
+                }
+                goto ext_call_fail;
+            }
+            Py_DECREF(kwdict);
+            kwdict = d;
+        }
+    }
+    if (flags & CALL_FLAG_VAR) {
+        stararg = EXT_POP(*pp_stack);
+        if (!PyTuple_Check(stararg)) {
+            PyObject *t = NULL;
+            t = PySequence_Tuple(stararg);
+            if (t == NULL) {
+                if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+                    PyErr_Format(PyExc_TypeError,
+                                 "%.200s%.200s argument after * "
+                                 "must be a sequence, not %200s",
+                                 PyEval_GetFuncName(func),
+                                 PyEval_GetFuncDesc(func),
+                                 stararg->ob_type->tp_name);
+                }
+                goto ext_call_fail;
+            }
+            Py_DECREF(stararg);
+            stararg = t;
+        }
+        nstar = PyTuple_GET_SIZE(stararg);
+    }
+    if (nk > 0) {
+        kwdict = update_keyword_args(kwdict, nk, pp_stack, func);
+        if (kwdict == NULL)
+            goto ext_call_fail;
+    }
+    callargs = update_star_args(na, nstar, stararg, pp_stack);
+    if (callargs == NULL)
+        goto ext_call_fail;
 #ifdef CALL_PROFILE
-	/* At this point, we have to look at the type of func to
-	   update the call stats properly.  Do it here so as to avoid
-	   exposing the call stats machinery outside ceval.c
-	*/
-	if (PyFunction_Check(func))
-		PCALL(PCALL_FUNCTION);
-	else if (PyMethod_Check(func))
-		PCALL(PCALL_METHOD);
-	else if (PyType_Check(func))
-		PCALL(PCALL_TYPE);
-	else if (PyCFunction_Check(func))
-		PCALL(PCALL_CFUNCTION);
-	else
-		PCALL(PCALL_OTHER);
+    /* At this point, we have to look at the type of func to
+       update the call stats properly.  Do it here so as to avoid
+       exposing the call stats machinery outside ceval.c
+    */
+    if (PyFunction_Check(func))
+        PCALL(PCALL_FUNCTION);
+    else if (PyMethod_Check(func))
+        PCALL(PCALL_METHOD);
+    else if (PyType_Check(func))
+        PCALL(PCALL_TYPE);
+    else if (PyCFunction_Check(func))
+        PCALL(PCALL_CFUNCTION);
+    else
+        PCALL(PCALL_OTHER);
 #endif
-	if (PyCFunction_Check(func)) {
-		PyThreadState *tstate = PyThreadState_GET();
-		C_TRACE(result, PyCFunction_Call(func, callargs, kwdict));
-	}
-	else
-		result = PyObject_Call(func, callargs, kwdict);
+    if (PyCFunction_Check(func)) {
+        PyThreadState *tstate = PyThreadState_GET();
+        C_TRACE(result, PyCFunction_Call(func, callargs, kwdict));
+    }
+    else
+        result = PyObject_Call(func, callargs, kwdict);
 ext_call_fail:
-	Py_XDECREF(callargs);
-	Py_XDECREF(kwdict);
-	Py_XDECREF(stararg);
-	return result;
+    Py_XDECREF(callargs);
+    Py_XDECREF(kwdict);
+    Py_XDECREF(stararg);
+    return result;
 }
 
 /* Extract a slice index from a PyInt or PyLong or an object with the
@@ -4343,93 +4343,93 @@ ext_call_fail:
 int
 _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
 {
-	if (v != NULL) {
-		Py_ssize_t x;
-		if (PyInt_Check(v)) {
-			/* XXX(nnorwitz): I think PyInt_AS_LONG is correct,
-			   however, it looks like it should be AsSsize_t.
-			   There should be a comment here explaining why.
-			*/
-			x = PyInt_AS_LONG(v);
-		}
-		else if (PyIndex_Check(v)) {
-			x = PyNumber_AsSsize_t(v, NULL);
-			if (x == -1 && PyErr_Occurred())
-				return 0;
-		}
-		else {
-			PyErr_SetString(PyExc_TypeError,
-					"slice indices must be integers or "
-					"None or have an __index__ method");
-			return 0;
-		}
-		*pi = x;
-	}
-	return 1;
+    if (v != NULL) {
+        Py_ssize_t x;
+        if (PyInt_Check(v)) {
+            /* XXX(nnorwitz): I think PyInt_AS_LONG is correct,
+               however, it looks like it should be AsSsize_t.
+               There should be a comment here explaining why.
+            */
+            x = PyInt_AS_LONG(v);
+        }
+        else if (PyIndex_Check(v)) {
+            x = PyNumber_AsSsize_t(v, NULL);
+            if (x == -1 && PyErr_Occurred())
+                return 0;
+        }
+        else {
+            PyErr_SetString(PyExc_TypeError,
+                            "slice indices must be integers or "
+                            "None or have an __index__ method");
+            return 0;
+        }
+        *pi = x;
+    }
+    return 1;
 }
 
 #undef ISINDEX
 #define ISINDEX(x) ((x) == NULL || \
-		    PyInt_Check(x) || PyLong_Check(x) || PyIndex_Check(x))
+                    PyInt_Check(x) || PyLong_Check(x) || PyIndex_Check(x))
 
 static PyObject *
 apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
 {
-	PyTypeObject *tp = u->ob_type;
-	PySequenceMethods *sq = tp->tp_as_sequence;
-
-	if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
-		Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
-		if (!_PyEval_SliceIndex(v, &ilow))
-			return NULL;
-		if (!_PyEval_SliceIndex(w, &ihigh))
-			return NULL;
-		return PySequence_GetSlice(u, ilow, ihigh);
-	}
-	else {
-		PyObject *slice = PySlice_New(v, w, NULL);
-		if (slice != NULL) {
-			PyObject *res = PyObject_GetItem(u, slice);
-			Py_DECREF(slice);
-			return res;
-		}
-		else
-			return NULL;
-	}
+    PyTypeObject *tp = u->ob_type;
+    PySequenceMethods *sq = tp->tp_as_sequence;
+
+    if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
+        Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
+        if (!_PyEval_SliceIndex(v, &ilow))
+            return NULL;
+        if (!_PyEval_SliceIndex(w, &ihigh))
+            return NULL;
+        return PySequence_GetSlice(u, ilow, ihigh);
+    }
+    else {
+        PyObject *slice = PySlice_New(v, w, NULL);
+        if (slice != NULL) {
+            PyObject *res = PyObject_GetItem(u, slice);
+            Py_DECREF(slice);
+            return res;
+        }
+        else
+            return NULL;
+    }
 }
 
 static int
 assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
-	/* u[v:w] = x */
+    /* u[v:w] = x */
 {
-	PyTypeObject *tp = u->ob_type;
-	PySequenceMethods *sq = tp->tp_as_sequence;
-
-	if (sq && sq->sq_ass_slice && ISINDEX(v) && ISINDEX(w)) {
-		Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
-		if (!_PyEval_SliceIndex(v, &ilow))
-			return -1;
-		if (!_PyEval_SliceIndex(w, &ihigh))
-			return -1;
-		if (x == NULL)
-			return PySequence_DelSlice(u, ilow, ihigh);
-		else
-			return PySequence_SetSlice(u, ilow, ihigh, x);
-	}
-	else {
-		PyObject *slice = PySlice_New(v, w, NULL);
-		if (slice != NULL) {
-			int res;
-			if (x != NULL)
-				res = PyObject_SetItem(u, slice, x);
-			else
-				res = PyObject_DelItem(u, slice);
-			Py_DECREF(slice);
-			return res;
-		}
-		else
-			return -1;
-	}
+    PyTypeObject *tp = u->ob_type;
+    PySequenceMethods *sq = tp->tp_as_sequence;
+
+    if (sq && sq->sq_ass_slice && ISINDEX(v) && ISINDEX(w)) {
+        Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
+        if (!_PyEval_SliceIndex(v, &ilow))
+            return -1;
+        if (!_PyEval_SliceIndex(w, &ihigh))
+            return -1;
+        if (x == NULL)
+            return PySequence_DelSlice(u, ilow, ihigh);
+        else
+            return PySequence_SetSlice(u, ilow, ihigh, x);
+    }
+    else {
+        PyObject *slice = PySlice_New(v, w, NULL);
+        if (slice != NULL) {
+            int res;
+            if (x != NULL)
+                res = PyObject_SetItem(u, slice, x);
+            else
+                res = PyObject_DelItem(u, slice);
+            Py_DECREF(slice);
+            return res;
+        }
+        else
+            return -1;
+    }
 }
 
 #define Py3kExceptionClass_Check(x)     \
@@ -4437,416 +4437,416 @@ assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
      PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS))
 
 #define CANNOT_CATCH_MSG "catching classes that don't inherit from " \
-			 "BaseException is not allowed in 3.x"
+                         "BaseException is not allowed in 3.x"
 
 static PyObject *
 cmp_outcome(int op, register PyObject *v, register PyObject *w)
 {
-	int res = 0;
-	switch (op) {
-	case PyCmp_IS:
-		res = (v == w);
-		break;
-	case PyCmp_IS_NOT:
-		res = (v != w);
-		break;
-	case PyCmp_IN:
-		res = PySequence_Contains(w, v);
-		if (res < 0)
-			return NULL;
-		break;
-	case PyCmp_NOT_IN:
-		res = PySequence_Contains(w, v);
-		if (res < 0)
-			return NULL;
-		res = !res;
-		break;
-	case PyCmp_EXC_MATCH:
-		if (PyTuple_Check(w)) {
-			Py_ssize_t i, length;
-			length = PyTuple_Size(w);
-			for (i = 0; i < length; i += 1) {
-				PyObject *exc = PyTuple_GET_ITEM(w, i);
-				if (PyString_Check(exc)) {
-					int ret_val;
-					ret_val = PyErr_WarnEx(
-						PyExc_DeprecationWarning,
-						"catching of string "
-						"exceptions is deprecated", 1);
-					if (ret_val < 0)
-						return NULL;
-				}
-				else if (Py_Py3kWarningFlag  &&
-					 !PyTuple_Check(exc) &&
-					 !Py3kExceptionClass_Check(exc))
-				{
-					int ret_val;
-					ret_val = PyErr_WarnEx(
-						PyExc_DeprecationWarning,
-						CANNOT_CATCH_MSG, 1);
-					if (ret_val < 0)
-						return NULL;
-				}
-			}
-		}
-		else {
-			if (PyString_Check(w)) {
-				int ret_val;
-				ret_val = PyErr_WarnEx(
-						PyExc_DeprecationWarning,
-						"catching of string "
-						"exceptions is deprecated", 1);
-				if (ret_val < 0)
-					return NULL;
-			}
-			else if (Py_Py3kWarningFlag  &&
-				 !PyTuple_Check(w) &&
-				 !Py3kExceptionClass_Check(w))
-			{
-				int ret_val;
-				ret_val = PyErr_WarnEx(
-					PyExc_DeprecationWarning,
-					CANNOT_CATCH_MSG, 1);
-				if (ret_val < 0)
-					return NULL;
-			}
-		}
-		res = PyErr_GivenExceptionMatches(v, w);
-		break;
-	default:
-		return PyObject_RichCompare(v, w, op);
-	}
-	v = res ? Py_True : Py_False;
-	Py_INCREF(v);
-	return v;
+    int res = 0;
+    switch (op) {
+    case PyCmp_IS:
+        res = (v == w);
+        break;
+    case PyCmp_IS_NOT:
+        res = (v != w);
+        break;
+    case PyCmp_IN:
+        res = PySequence_Contains(w, v);
+        if (res < 0)
+            return NULL;
+        break;
+    case PyCmp_NOT_IN:
+        res = PySequence_Contains(w, v);
+        if (res < 0)
+            return NULL;
+        res = !res;
+        break;
+    case PyCmp_EXC_MATCH:
+        if (PyTuple_Check(w)) {
+            Py_ssize_t i, length;
+            length = PyTuple_Size(w);
+            for (i = 0; i < length; i += 1) {
+                PyObject *exc = PyTuple_GET_ITEM(w, i);
+                if (PyString_Check(exc)) {
+                    int ret_val;
+                    ret_val = PyErr_WarnEx(
+                        PyExc_DeprecationWarning,
+                        "catching of string "
+                        "exceptions is deprecated", 1);
+                    if (ret_val < 0)
+                        return NULL;
+                }
+                else if (Py_Py3kWarningFlag  &&
+                         !PyTuple_Check(exc) &&
+                         !Py3kExceptionClass_Check(exc))
+                {
+                    int ret_val;
+                    ret_val = PyErr_WarnEx(
+                        PyExc_DeprecationWarning,
+                        CANNOT_CATCH_MSG, 1);
+                    if (ret_val < 0)
+                        return NULL;
+                }
+            }
+        }
+        else {
+            if (PyString_Check(w)) {
+                int ret_val;
+                ret_val = PyErr_WarnEx(
+                                PyExc_DeprecationWarning,
+                                "catching of string "
+                                "exceptions is deprecated", 1);
+                if (ret_val < 0)
+                    return NULL;
+            }
+            else if (Py_Py3kWarningFlag  &&
+                     !PyTuple_Check(w) &&
+                     !Py3kExceptionClass_Check(w))
+            {
+                int ret_val;
+                ret_val = PyErr_WarnEx(
+                    PyExc_DeprecationWarning,
+                    CANNOT_CATCH_MSG, 1);
+                if (ret_val < 0)
+                    return NULL;
+            }
+        }
+        res = PyErr_GivenExceptionMatches(v, w);
+        break;
+    default:
+        return PyObject_RichCompare(v, w, op);
+    }
+    v = res ? Py_True : Py_False;
+    Py_INCREF(v);
+    return v;
 }
 
 static PyObject *
 import_from(PyObject *v, PyObject *name)
 {
-	PyObject *x;
-
-	x = PyObject_GetAttr(v, name);
-	if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
-		PyErr_Format(PyExc_ImportError,
-			     "cannot import name %.230s",
-			     PyString_AsString(name));
-	}
-	return x;
+    PyObject *x;
+
+    x = PyObject_GetAttr(v, name);
+    if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Format(PyExc_ImportError,
+                     "cannot import name %.230s",
+                     PyString_AsString(name));
+    }
+    return x;
 }
 
 static int
 import_all_from(PyObject *locals, PyObject *v)
 {
-	PyObject *all = PyObject_GetAttrString(v, "__all__");
-	PyObject *dict, *name, *value;
-	int skip_leading_underscores = 0;
-	int pos, err;
-
-	if (all == NULL) {
-		if (!PyErr_ExceptionMatches(PyExc_AttributeError))
-			return -1; /* Unexpected error */
-		PyErr_Clear();
-		dict = PyObject_GetAttrString(v, "__dict__");
-		if (dict == NULL) {
-			if (!PyErr_ExceptionMatches(PyExc_AttributeError))
-				return -1;
-			PyErr_SetString(PyExc_ImportError,
-			"from-import-* object has no __dict__ and no __all__");
-			return -1;
-		}
-		all = PyMapping_Keys(dict);
-		Py_DECREF(dict);
-		if (all == NULL)
-			return -1;
-		skip_leading_underscores = 1;
-	}
-
-	for (pos = 0, err = 0; ; pos++) {
-		name = PySequence_GetItem(all, pos);
-		if (name == NULL) {
-			if (!PyErr_ExceptionMatches(PyExc_IndexError))
-				err = -1;
-			else
-				PyErr_Clear();
-			break;
-		}
-		if (skip_leading_underscores &&
-		    PyString_Check(name) &&
-		    PyString_AS_STRING(name)[0] == '_')
-		{
-			Py_DECREF(name);
-			continue;
-		}
-		value = PyObject_GetAttr(v, name);
-		if (value == NULL)
-			err = -1;
-		else if (PyDict_CheckExact(locals))
-			err = PyDict_SetItem(locals, name, value);
-		else
-			err = PyObject_SetItem(locals, name, value);
-		Py_DECREF(name);
-		Py_XDECREF(value);
-		if (err != 0)
-			break;
-	}
-	Py_DECREF(all);
-	return err;
+    PyObject *all = PyObject_GetAttrString(v, "__all__");
+    PyObject *dict, *name, *value;
+    int skip_leading_underscores = 0;
+    int pos, err;
+
+    if (all == NULL) {
+        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+            return -1; /* Unexpected error */
+        PyErr_Clear();
+        dict = PyObject_GetAttrString(v, "__dict__");
+        if (dict == NULL) {
+            if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+                return -1;
+            PyErr_SetString(PyExc_ImportError,
+            "from-import-* object has no __dict__ and no __all__");
+            return -1;
+        }
+        all = PyMapping_Keys(dict);
+        Py_DECREF(dict);
+        if (all == NULL)
+            return -1;
+        skip_leading_underscores = 1;
+    }
+
+    for (pos = 0, err = 0; ; pos++) {
+        name = PySequence_GetItem(all, pos);
+        if (name == NULL) {
+            if (!PyErr_ExceptionMatches(PyExc_IndexError))
+                err = -1;
+            else
+                PyErr_Clear();
+            break;
+        }
+        if (skip_leading_underscores &&
+            PyString_Check(name) &&
+            PyString_AS_STRING(name)[0] == '_')
+        {
+            Py_DECREF(name);
+            continue;
+        }
+        value = PyObject_GetAttr(v, name);
+        if (value == NULL)
+            err = -1;
+        else if (PyDict_CheckExact(locals))
+            err = PyDict_SetItem(locals, name, value);
+        else
+            err = PyObject_SetItem(locals, name, value);
+        Py_DECREF(name);
+        Py_XDECREF(value);
+        if (err != 0)
+            break;
+    }
+    Py_DECREF(all);
+    return err;
 }
 
 static PyObject *
 build_class(PyObject *methods, PyObject *bases, PyObject *name)
 {
-	PyObject *metaclass = NULL, *result, *base;
-
-	if (PyDict_Check(methods))
-		metaclass = PyDict_GetItemString(methods, "__metaclass__");
-	if (metaclass != NULL)
-		Py_INCREF(metaclass);
-	else if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
-		base = PyTuple_GET_ITEM(bases, 0);
-		metaclass = PyObject_GetAttrString(base, "__class__");
-		if (metaclass == NULL) {
-			PyErr_Clear();
-			metaclass = (PyObject *)base->ob_type;
-			Py_INCREF(metaclass);
-		}
-	}
-	else {
-		PyObject *g = PyEval_GetGlobals();
-		if (g != NULL && PyDict_Check(g))
-			metaclass = PyDict_GetItemString(g, "__metaclass__");
-		if (metaclass == NULL)
-			metaclass = (PyObject *) &PyClass_Type;
-		Py_INCREF(metaclass);
-	}
-	result = PyObject_CallFunctionObjArgs(metaclass, name, bases, methods,
-					      NULL);
-	Py_DECREF(metaclass);
-	if (result == NULL && PyErr_ExceptionMatches(PyExc_TypeError)) {
-		/* A type error here likely means that the user passed
-		   in a base that was not a class (such the random module
-		   instead of the random.random type).  Help them out with
-		   by augmenting the error message with more information.*/
-
-		PyObject *ptype, *pvalue, *ptraceback;
-
-		PyErr_Fetch(&ptype, &pvalue, &ptraceback);
-		if (PyString_Check(pvalue)) {
-			PyObject *newmsg;
-			newmsg = PyString_FromFormat(
-				"Error when calling the metaclass bases\n"
-				"    %s",
-				PyString_AS_STRING(pvalue));
-			if (newmsg != NULL) {
-				Py_DECREF(pvalue);
-				pvalue = newmsg;
-			}
-		}
-		PyErr_Restore(ptype, pvalue, ptraceback);
-	}
-	return result;
+    PyObject *metaclass = NULL, *result, *base;
+
+    if (PyDict_Check(methods))
+        metaclass = PyDict_GetItemString(methods, "__metaclass__");
+    if (metaclass != NULL)
+        Py_INCREF(metaclass);
+    else if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
+        base = PyTuple_GET_ITEM(bases, 0);
+        metaclass = PyObject_GetAttrString(base, "__class__");
+        if (metaclass == NULL) {
+            PyErr_Clear();
+            metaclass = (PyObject *)base->ob_type;
+            Py_INCREF(metaclass);
+        }
+    }
+    else {
+        PyObject *g = PyEval_GetGlobals();
+        if (g != NULL && PyDict_Check(g))
+            metaclass = PyDict_GetItemString(g, "__metaclass__");
+        if (metaclass == NULL)
+            metaclass = (PyObject *) &PyClass_Type;
+        Py_INCREF(metaclass);
+    }
+    result = PyObject_CallFunctionObjArgs(metaclass, name, bases, methods,
+                                          NULL);
+    Py_DECREF(metaclass);
+    if (result == NULL && PyErr_ExceptionMatches(PyExc_TypeError)) {
+        /* A type error here likely means that the user passed
+           in a base that was not a class (such the random module
+           instead of the random.random type).  Help them out with
+           by augmenting the error message with more information.*/
+
+        PyObject *ptype, *pvalue, *ptraceback;
+
+        PyErr_Fetch(&ptype, &pvalue, &ptraceback);
+        if (PyString_Check(pvalue)) {
+            PyObject *newmsg;
+            newmsg = PyString_FromFormat(
+                "Error when calling the metaclass bases\n"
+                "    %s",
+                PyString_AS_STRING(pvalue));
+            if (newmsg != NULL) {
+                Py_DECREF(pvalue);
+                pvalue = newmsg;
+            }
+        }
+        PyErr_Restore(ptype, pvalue, ptraceback);
+    }
+    return result;
 }
 
 static int
 exec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals,
-	       PyObject *locals)
+               PyObject *locals)
 {
-	int n;
-	PyObject *v;
-	int plain = 0;
-
-	if (PyTuple_Check(prog) && globals == Py_None && locals == Py_None &&
-	    ((n = PyTuple_Size(prog)) == 2 || n == 3)) {
-		/* Backward compatibility hack */
-		globals = PyTuple_GetItem(prog, 1);
-		if (n == 3)
-			locals = PyTuple_GetItem(prog, 2);
-		prog = PyTuple_GetItem(prog, 0);
-	}
-	if (globals == Py_None) {
-		globals = PyEval_GetGlobals();
-		if (locals == Py_None) {
-			locals = PyEval_GetLocals();
-			plain = 1;
-		}
-		if (!globals || !locals) {
-			PyErr_SetString(PyExc_SystemError,
-					"globals and locals cannot be NULL");
-			return -1;
-		}
-	}
-	else if (locals == Py_None)
-		locals = globals;
-	if (!PyString_Check(prog) &&
+    int n;
+    PyObject *v;
+    int plain = 0;
+
+    if (PyTuple_Check(prog) && globals == Py_None && locals == Py_None &&
+        ((n = PyTuple_Size(prog)) == 2 || n == 3)) {
+        /* Backward compatibility hack */
+        globals = PyTuple_GetItem(prog, 1);
+        if (n == 3)
+            locals = PyTuple_GetItem(prog, 2);
+        prog = PyTuple_GetItem(prog, 0);
+    }
+    if (globals == Py_None) {
+        globals = PyEval_GetGlobals();
+        if (locals == Py_None) {
+            locals = PyEval_GetLocals();
+            plain = 1;
+        }
+        if (!globals || !locals) {
+            PyErr_SetString(PyExc_SystemError,
+                            "globals and locals cannot be NULL");
+            return -1;
+        }
+    }
+    else if (locals == Py_None)
+        locals = globals;
+    if (!PyString_Check(prog) &&
 #ifdef Py_USING_UNICODE
-	    !PyUnicode_Check(prog) &&
+        !PyUnicode_Check(prog) &&
 #endif
-	    !PyCode_Check(prog) &&
-	    !PyFile_Check(prog)) {
-		PyErr_SetString(PyExc_TypeError,
-			"exec: arg 1 must be a string, file, or code object");
-		return -1;
-	}
-	if (!PyDict_Check(globals)) {
-		PyErr_SetString(PyExc_TypeError,
-		    "exec: arg 2 must be a dictionary or None");
-		return -1;
-	}
-	if (!PyMapping_Check(locals)) {
-		PyErr_SetString(PyExc_TypeError,
-		    "exec: arg 3 must be a mapping or None");
-		return -1;
-	}
-	if (PyDict_GetItemString(globals, "__builtins__") == NULL)
-		PyDict_SetItemString(globals, "__builtins__", f->f_builtins);
-	if (PyCode_Check(prog)) {
-		if (PyCode_GetNumFree((PyCodeObject *)prog) > 0) {
-			PyErr_SetString(PyExc_TypeError,
-		"code object passed to exec may not contain free variables");
-			return -1;
-		}
-		v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);
-	}
-	else if (PyFile_Check(prog)) {
-		FILE *fp = PyFile_AsFile(prog);
-		char *name = PyString_AsString(PyFile_Name(prog));
-		PyCompilerFlags cf;
-		if (name == NULL)
-			return -1;
-		cf.cf_flags = 0;
-		if (PyEval_MergeCompilerFlags(&cf))
-			v = PyRun_FileFlags(fp, name, Py_file_input, globals,
-					    locals, &cf);
-		else
-			v = PyRun_File(fp, name, Py_file_input, globals,
-				       locals);
-	}
-	else {
-		PyObject *tmp = NULL;
-		char *str;
-		PyCompilerFlags cf;
-		cf.cf_flags = 0;
+        !PyCode_Check(prog) &&
+        !PyFile_Check(prog)) {
+        PyErr_SetString(PyExc_TypeError,
+            "exec: arg 1 must be a string, file, or code object");
+        return -1;
+    }
+    if (!PyDict_Check(globals)) {
+        PyErr_SetString(PyExc_TypeError,
+            "exec: arg 2 must be a dictionary or None");
+        return -1;
+    }
+    if (!PyMapping_Check(locals)) {
+        PyErr_SetString(PyExc_TypeError,
+            "exec: arg 3 must be a mapping or None");
+        return -1;
+    }
+    if (PyDict_GetItemString(globals, "__builtins__") == NULL)
+        PyDict_SetItemString(globals, "__builtins__", f->f_builtins);
+    if (PyCode_Check(prog)) {
+        if (PyCode_GetNumFree((PyCodeObject *)prog) > 0) {
+            PyErr_SetString(PyExc_TypeError,
+        "code object passed to exec may not contain free variables");
+            return -1;
+        }
+        v = PyEval_EvalCode((PyCodeObject *) prog, globals, locals);
+    }
+    else if (PyFile_Check(prog)) {
+        FILE *fp = PyFile_AsFile(prog);
+        char *name = PyString_AsString(PyFile_Name(prog));
+        PyCompilerFlags cf;
+        if (name == NULL)
+            return -1;
+        cf.cf_flags = 0;
+        if (PyEval_MergeCompilerFlags(&cf))
+            v = PyRun_FileFlags(fp, name, Py_file_input, globals,
+                                locals, &cf);
+        else
+            v = PyRun_File(fp, name, Py_file_input, globals,
+                           locals);
+    }
+    else {
+        PyObject *tmp = NULL;
+        char *str;
+        PyCompilerFlags cf;
+        cf.cf_flags = 0;
 #ifdef Py_USING_UNICODE
-		if (PyUnicode_Check(prog)) {
-			tmp = PyUnicode_AsUTF8String(prog);
-			if (tmp == NULL)
-				return -1;
-			prog = tmp;
-			cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
-		}
+        if (PyUnicode_Check(prog)) {
+            tmp = PyUnicode_AsUTF8String(prog);
+            if (tmp == NULL)
+                return -1;
+            prog = tmp;
+            cf.cf_flags |= PyCF_SOURCE_IS_UTF8;
+        }
 #endif
-		if (PyString_AsStringAndSize(prog, &str, NULL))
-			return -1;
-		if (PyEval_MergeCompilerFlags(&cf))
-			v = PyRun_StringFlags(str, Py_file_input, globals,
-					      locals, &cf);
-		else
-			v = PyRun_String(str, Py_file_input, globals, locals);
-		Py_XDECREF(tmp);
-	}
-	if (plain)
-		PyFrame_LocalsToFast(f, 0);
-	if (v == NULL)
-		return -1;
-	Py_DECREF(v);
-	return 0;
+        if (PyString_AsStringAndSize(prog, &str, NULL))
+            return -1;
+        if (PyEval_MergeCompilerFlags(&cf))
+            v = PyRun_StringFlags(str, Py_file_input, globals,
+                                  locals, &cf);
+        else
+            v = PyRun_String(str, Py_file_input, globals, locals);
+        Py_XDECREF(tmp);
+    }
+    if (plain)
+        PyFrame_LocalsToFast(f, 0);
+    if (v == NULL)
+        return -1;
+    Py_DECREF(v);
+    return 0;
 }
 
 static void
 format_exc_check_arg(PyObject *exc, char *format_str, PyObject *obj)
 {
-	char *obj_str;
+    char *obj_str;
 
-	if (!obj)
-		return;
+    if (!obj)
+        return;
 
-	obj_str = PyString_AsString(obj);
-	if (!obj_str)
-		return;
+    obj_str = PyString_AsString(obj);
+    if (!obj_str)
+        return;
 
-	PyErr_Format(exc, format_str, obj_str);
+    PyErr_Format(exc, format_str, obj_str);
 }
 
 static PyObject *
 string_concatenate(PyObject *v, PyObject *w,
-		   PyFrameObject *f, unsigned char *next_instr)
+                   PyFrameObject *f, unsigned char *next_instr)
 {
-	/* This function implements 'variable += expr' when both arguments
-	   are strings. */
-	Py_ssize_t v_len = PyString_GET_SIZE(v);
-	Py_ssize_t w_len = PyString_GET_SIZE(w);
-	Py_ssize_t new_len = v_len + w_len;
-	if (new_len < 0) {
-		PyErr_SetString(PyExc_OverflowError,
-				"strings are too large to concat");
-		return NULL;
-	}
-
-	if (v->ob_refcnt == 2) {
-		/* In the common case, there are 2 references to the value
-		 * stored in 'variable' when the += is performed: one on the
-		 * value stack (in 'v') and one still stored in the
-		 * 'variable'.  We try to delete the variable now to reduce
-		 * the refcnt to 1.
-		 */
-		switch (*next_instr) {
-		case STORE_FAST:
-		{
-			int oparg = PEEKARG();
-			PyObject **fastlocals = f->f_localsplus;
-			if (GETLOCAL(oparg) == v)
-				SETLOCAL(oparg, NULL);
-			break;
-		}
-		case STORE_DEREF:
-		{
-			PyObject **freevars = (f->f_localsplus +
-					       f->f_code->co_nlocals);
-			PyObject *c = freevars[PEEKARG()];
-			if (PyCell_GET(c) == v)
-				PyCell_Set(c, NULL);
-			break;
-		}
-		case STORE_NAME:
-		{
-			PyObject *names = f->f_code->co_names;
-			PyObject *name = GETITEM(names, PEEKARG());
-			PyObject *locals = f->f_locals;
-			if (PyDict_CheckExact(locals) &&
-			    PyDict_GetItem(locals, name) == v) {
-				if (PyDict_DelItem(locals, name) != 0) {
-					PyErr_Clear();
-				}
-			}
-			break;
-		}
-		}
-	}
-
-	if (v->ob_refcnt == 1 && !PyString_CHECK_INTERNED(v)) {
-		/* Now we own the last reference to 'v', so we can resize it
-		 * in-place.
-		 */
-		if (_PyString_Resize(&v, new_len) != 0) {
-			/* XXX if _PyString_Resize() fails, 'v' has been
-			 * deallocated so it cannot be put back into
-			 * 'variable'.  The MemoryError is raised when there
-			 * is no value in 'variable', which might (very
-			 * remotely) be a cause of incompatibilities.
-			 */
-			return NULL;
-		}
-		/* copy 'w' into the newly allocated area of 'v' */
-		memcpy(PyString_AS_STRING(v) + v_len,
-		       PyString_AS_STRING(w), w_len);
-		return v;
-	}
-	else {
-		/* When in-place resizing is not an option. */
-		PyString_Concat(&v, w);
-		return v;
-	}
+    /* This function implements 'variable += expr' when both arguments
+       are strings. */
+    Py_ssize_t v_len = PyString_GET_SIZE(v);
+    Py_ssize_t w_len = PyString_GET_SIZE(w);
+    Py_ssize_t new_len = v_len + w_len;
+    if (new_len < 0) {
+        PyErr_SetString(PyExc_OverflowError,
+                        "strings are too large to concat");
+        return NULL;
+    }
+
+    if (v->ob_refcnt == 2) {
+        /* In the common case, there are 2 references to the value
+         * stored in 'variable' when the += is performed: one on the
+         * value stack (in 'v') and one still stored in the
+         * 'variable'.  We try to delete the variable now to reduce
+         * the refcnt to 1.
+         */
+        switch (*next_instr) {
+        case STORE_FAST:
+        {
+            int oparg = PEEKARG();
+            PyObject **fastlocals = f->f_localsplus;
+            if (GETLOCAL(oparg) == v)
+                SETLOCAL(oparg, NULL);
+            break;
+        }
+        case STORE_DEREF:
+        {
+            PyObject **freevars = (f->f_localsplus +
+                                   f->f_code->co_nlocals);
+            PyObject *c = freevars[PEEKARG()];
+            if (PyCell_GET(c) == v)
+                PyCell_Set(c, NULL);
+            break;
+        }
+        case STORE_NAME:
+        {
+            PyObject *names = f->f_code->co_names;
+            PyObject *name = GETITEM(names, PEEKARG());
+            PyObject *locals = f->f_locals;
+            if (PyDict_CheckExact(locals) &&
+                PyDict_GetItem(locals, name) == v) {
+                if (PyDict_DelItem(locals, name) != 0) {
+                    PyErr_Clear();
+                }
+            }
+            break;
+        }
+        }
+    }
+
+    if (v->ob_refcnt == 1 && !PyString_CHECK_INTERNED(v)) {
+        /* Now we own the last reference to 'v', so we can resize it
+         * in-place.
+         */
+        if (_PyString_Resize(&v, new_len) != 0) {
+            /* XXX if _PyString_Resize() fails, 'v' has been
+             * deallocated so it cannot be put back into
+             * 'variable'.  The MemoryError is raised when there
+             * is no value in 'variable', which might (very
+             * remotely) be a cause of incompatibilities.
+             */
+            return NULL;
+        }
+        /* copy 'w' into the newly allocated area of 'v' */
+        memcpy(PyString_AS_STRING(v) + v_len,
+               PyString_AS_STRING(w), w_len);
+        return v;
+    }
+    else {
+        /* When in-place resizing is not an option. */
+        PyString_Concat(&v, w);
+        return v;
+    }
 }
 
 #ifdef DYNAMIC_EXECUTION_PROFILE
@@ -4854,40 +4854,40 @@ string_concatenate(PyObject *v, PyObject *w,
 static PyObject *
 getarray(long a[256])
 {
-	int i;
-	PyObject *l = PyList_New(256);
-	if (l == NULL) return NULL;
-	for (i = 0; i < 256; i++) {
-		PyObject *x = PyInt_FromLong(a[i]);
-		if (x == NULL) {
-			Py_DECREF(l);
-			return NULL;
-		}
-		PyList_SetItem(l, i, x);
-	}
-	for (i = 0; i < 256; i++)
-		a[i] = 0;
-	return l;
+    int i;
+    PyObject *l = PyList_New(256);
+    if (l == NULL) return NULL;
+    for (i = 0; i < 256; i++) {
+        PyObject *x = PyInt_FromLong(a[i]);
+        if (x == NULL) {
+            Py_DECREF(l);
+            return NULL;
+        }
+        PyList_SetItem(l, i, x);
+    }
+    for (i = 0; i < 256; i++)
+        a[i] = 0;
+    return l;
 }
 
 PyObject *
 _Py_GetDXProfile(PyObject *self, PyObject *args)
 {
 #ifndef DXPAIRS
-	return getarray(dxp);
+    return getarray(dxp);
 #else
-	int i;
-	PyObject *l = PyList_New(257);
-	if (l == NULL) return NULL;
-	for (i = 0; i < 257; i++) {
-		PyObject *x = getarray(dxpairs[i]);
-		if (x == NULL) {
-			Py_DECREF(l);
-			return NULL;
-		}
-		PyList_SetItem(l, i, x);
-	}
-	return l;
+    int i;
+    PyObject *l = PyList_New(257);
+    if (l == NULL) return NULL;
+    for (i = 0; i < 257; i++) {
+        PyObject *x = getarray(dxpairs[i]);
+        if (x == NULL) {
+            Py_DECREF(l);
+            return NULL;
+        }
+        PyList_SetItem(l, i, x);
+    }
+    return l;
 #endif
 }
 
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 @@ Copyright (c) Corporation for National Research Initiatives.
 /* --- 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 @@ int PyCodec_Register(PyObject *search_function)
 {
     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 @@ PyObject *normalizestring(const char *string)
     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 @@ PyObject *normalizestring(const char *string)
             ch = '-';
         else
             ch = tolower(Py_CHARMASK(ch));
-	p[i] = ch;
+        p[i] = ch;
     }
     return v;
 }
@@ -83,7 +83,7 @@ PyObject *normalizestring(const char *string)
    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 @@ PyObject *_PyCodec_Lookup(const char *encoding)
     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 @@ PyObject *_PyCodec_Lookup(const char *encoding)
 
 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 @@ PyObject *codec_getitem(const char *encoding, int index)
 
     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 @@ PyObject *codec_getitem(const char *encoding, int index)
 
 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 @@ PyObject *codec_getincrementalcodec(const char *encoding,
 
 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_Decoder(const char *encoding)
 }
 
 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 @@ PyObject *PyCodec_StreamWriter(const char *encoding,
    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 @@ PyObject *PyCodec_Encode(PyObject *object,
 
     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 @@ PyObject *PyCodec_Encode(PyObject *object,
     Py_DECREF(encoder);
     Py_DECREF(result);
     return v;
-	
+
  onError:
     Py_XDECREF(result);
     Py_XDECREF(args);
@@ -359,8 +359,8 @@ PyObject *PyCodec_Encode(PyObject *object,
    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 @@ PyObject *PyCodec_Decode(PyObject *object,
 
     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 @@ PyObject *PyCodec_Decode(PyObject *object,
     Py_DECREF(decoder);
     Py_DECREF(result);
     return v;
-	
+
  onError:
     Py_XDECREF(args);
     Py_XDECREF(decoder);
@@ -409,13 +409,13 @@ int PyCodec_RegisterError(const char *name, PyObject *error)
 {
     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 @@ PyObject *PyCodec_LookupError(const char *name)
 
     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 @@ static void wrong_exception_type(PyObject *exc)
 {
     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 @@ PyObject *PyCodec_StrictErrors(PyObject *exc)
     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 @@ PyObject *PyCodec_IgnoreErrors(PyObject *exc)
 {
     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 @@ PyObject *PyCodec_ReplaceErrors(PyObject *exc)
     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 @@ static Py_UNICODE hexdigits[] = {
 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];
-	}
-
-	restuple = Py_BuildValue("(On)", res, end);
-	Py_DECREF(res);
-	Py_DECREF(object);
-	return restuple;
+            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;
     }
     else {
-	wrong_exception_type(exc);
-	return NULL;
+        wrong_exception_type(exc);
+        return NULL;
     }
 }
 #endif
@@ -765,63 +765,63 @@ static PyObject *backslashreplace_errors(PyObject *self, PyObject *exc)
 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 @@ static int _PyCodecRegistry_Init(void)
     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;
diff --git a/Python/compile.c b/Python/compile.c
index 90cf065..a8571d2 100644
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -5,10 +5,10 @@
  * PyCodeObject.  The compiler makes several passes to build the code
  * object:
  *   1. Checks for future statements.  See future.c
- *   2. Builds a symbol table.	See symtable.c.
+ *   2. Builds a symbol table.  See symtable.c.
  *   3. Generate code for basic blocks.  See compiler_mod() in this file.
  *   4. Assemble the basic blocks into final code.  See assemble() in
- *	this file.	 
+ *      this file.
  *   5. Optimize the byte code (peephole optimizations).  See peephole.c
  *
  * Note that compiler_mod() suggests module, but the module ast type
@@ -44,37 +44,37 @@ int Py_OptimizeFlag = 0;
 #define COMP_DICTCOMP 2
 
 struct instr {
-	unsigned i_jabs : 1;
-	unsigned i_jrel : 1;
-	unsigned i_hasarg : 1;
-	unsigned char i_opcode;
-	int i_oparg;
-	struct basicblock_ *i_target; /* target block (if jump instruction) */
-	int i_lineno;
+    unsigned i_jabs : 1;
+    unsigned i_jrel : 1;
+    unsigned i_hasarg : 1;
+    unsigned char i_opcode;
+    int i_oparg;
+    struct basicblock_ *i_target; /* target block (if jump instruction) */
+    int i_lineno;
 };
 
 typedef struct basicblock_ {
     /* Each basicblock in a compilation unit is linked via b_list in the
        reverse order that the block are allocated.  b_list points to the next
        block, not to be confused with b_next, which is next by control flow. */
-	struct basicblock_ *b_list;
-	/* number of instructions used */
-	int b_iused;
-	/* length of instruction array (b_instr) */
-	int b_ialloc;
-	/* pointer to an array of instructions, initially NULL */
-	struct instr *b_instr;
-	/* If b_next is non-NULL, it is a pointer to the next
-	   block reached by normal control flow. */
-	struct basicblock_ *b_next;
-	/* b_seen is used to perform a DFS of basicblocks. */
-	unsigned b_seen : 1;
-	/* b_return is true if a RETURN_VALUE opcode is inserted. */
-	unsigned b_return : 1;
-	/* depth of stack upon entry of block, computed by stackdepth() */
-	int b_startdepth;
-	/* instruction offset for block, computed by assemble_jump_offsets() */
-	int b_offset;
+    struct basicblock_ *b_list;
+    /* number of instructions used */
+    int b_iused;
+    /* length of instruction array (b_instr) */
+    int b_ialloc;
+    /* pointer to an array of instructions, initially NULL */
+    struct instr *b_instr;
+    /* If b_next is non-NULL, it is a pointer to the next
+       block reached by normal control flow. */
+    struct basicblock_ *b_next;
+    /* b_seen is used to perform a DFS of basicblocks. */
+    unsigned b_seen : 1;
+    /* b_return is true if a RETURN_VALUE opcode is inserted. */
+    unsigned b_return : 1;
+    /* depth of stack upon entry of block, computed by stackdepth() */
+    int b_startdepth;
+    /* instruction offset for block, computed by assemble_jump_offsets() */
+    int b_offset;
 } basicblock;
 
 /* fblockinfo tracks the current frame block.
@@ -87,63 +87,63 @@ compiler IR.
 enum fblocktype { LOOP, EXCEPT, FINALLY_TRY, FINALLY_END };
 
 struct fblockinfo {
-	enum fblocktype fb_type;
-	basicblock *fb_block;
+    enum fblocktype fb_type;
+    basicblock *fb_block;
 };
 
 /* The following items change on entry and exit of code blocks.
    They must be saved and restored when returning to a block.
 */
 struct compiler_unit {
-	PySTEntryObject *u_ste;
-
-	PyObject *u_name;
-	/* The following fields are dicts that map objects to
-	   the index of them in co_XXX.	 The index is used as
-	   the argument for opcodes that refer to those collections.
-	*/
-	PyObject *u_consts;    /* all constants */
-	PyObject *u_names;     /* all names */
-	PyObject *u_varnames;  /* local variables */
-	PyObject *u_cellvars;  /* cell variables */
-	PyObject *u_freevars;  /* free variables */
-
-	PyObject *u_private;	/* for private name mangling */
-
-	int u_argcount;	   /* number of arguments for block */ 
-	/* Pointer to the most recently allocated block.  By following b_list
-	   members, you can reach all early allocated blocks. */
-	basicblock *u_blocks;
-	basicblock *u_curblock; /* pointer to current block */
-
-	int u_nfblocks;
-	struct fblockinfo u_fblock[CO_MAXBLOCKS];
-
-	int u_firstlineno; /* the first lineno of the block */
-	int u_lineno;	   /* the lineno for the current stmt */
-	bool u_lineno_set; /* boolean to indicate whether instr
-			      has been generated with current lineno */
+    PySTEntryObject *u_ste;
+
+    PyObject *u_name;
+    /* The following fields are dicts that map objects to
+       the index of them in co_XXX.      The index is used as
+       the argument for opcodes that refer to those collections.
+    */
+    PyObject *u_consts;    /* all constants */
+    PyObject *u_names;     /* all names */
+    PyObject *u_varnames;  /* local variables */
+    PyObject *u_cellvars;  /* cell variables */
+    PyObject *u_freevars;  /* free variables */
+
+    PyObject *u_private;        /* for private name mangling */
+
+    int u_argcount;        /* number of arguments for block */
+    /* Pointer to the most recently allocated block.  By following b_list
+       members, you can reach all early allocated blocks. */
+    basicblock *u_blocks;
+    basicblock *u_curblock; /* pointer to current block */
+
+    int u_nfblocks;
+    struct fblockinfo u_fblock[CO_MAXBLOCKS];
+
+    int u_firstlineno; /* the first lineno of the block */
+    int u_lineno;          /* the lineno for the current stmt */
+    bool u_lineno_set; /* boolean to indicate whether instr
+                          has been generated with current lineno */
 };
 
-/* This struct captures the global state of a compilation.  
+/* This struct captures the global state of a compilation.
 
 The u pointer points to the current compilation unit, while units
-for enclosing blocks are stored in c_stack.	The u and c_stack are
+for enclosing blocks are stored in c_stack.     The u and c_stack are
 managed by compiler_enter_scope() and compiler_exit_scope().
 */
 
 struct compiler {
-	const char *c_filename;
-	struct symtable *c_st;
-	PyFutureFeatures *c_future; /* pointer to module's __future__ */
-	PyCompilerFlags *c_flags;
+    const char *c_filename;
+    struct symtable *c_st;
+    PyFutureFeatures *c_future; /* pointer to module's __future__ */
+    PyCompilerFlags *c_flags;
 
-	int c_interactive;	 /* true if in interactive mode */
-	int c_nestlevel;
+    int c_interactive;           /* true if in interactive mode */
+    int c_nestlevel;
 
-	struct compiler_unit *u; /* compiler state for current block */
-	PyObject *c_stack;	 /* Python list holding compiler_unit ptrs */
-	PyArena *c_arena;	 /* pointer to memory allocation arena */
+    struct compiler_unit *u; /* compiler state for current block */
+    PyObject *c_stack;           /* Python list holding compiler_unit ptrs */
+    PyArena *c_arena;            /* pointer to memory allocation arena */
 };
 
 static int compiler_enter_scope(struct compiler *, identifier, void *, int);
@@ -164,12 +164,12 @@ static int compiler_visit_keyword(struct compiler *, keyword_ty);
 static int compiler_visit_expr(struct compiler *, expr_ty);
 static int compiler_augassign(struct compiler *, stmt_ty);
 static int compiler_visit_slice(struct compiler *, slice_ty,
-				expr_context_ty);
+                                expr_context_ty);
 
 static int compiler_push_fblock(struct compiler *, enum fblocktype,
-				basicblock *);
+                                basicblock *);
 static void compiler_pop_fblock(struct compiler *, enum fblocktype,
-				basicblock *);
+                                basicblock *);
 /* Returns true if there is a loop on the fblock stack. */
 static int compiler_in_loop(struct compiler *);
 
@@ -186,172 +186,172 @@ static PyObject *__doc__;
 PyObject *
 _Py_Mangle(PyObject *privateobj, PyObject *ident)
 {
-	/* Name mangling: __private becomes _classname__private.
-	   This is independent from how the name is used. */
-	const char *p, *name = PyString_AsString(ident);
-	char *buffer;
-	size_t nlen, plen;
-	if (privateobj == NULL || !PyString_Check(privateobj) ||
-	    name == NULL || name[0] != '_' || name[1] != '_') {
-		Py_INCREF(ident);
-		return ident;
-	}
-	p = PyString_AsString(privateobj);
-	nlen = strlen(name);
-	/* Don't mangle __id__ or names with dots.
-
-	   The only time a name with a dot can occur is when
-	   we are compiling an import statement that has a 
-	   package name.
-
-	   TODO(jhylton): Decide whether we want to support
-	   mangling of the module name, e.g. __M.X.
-	*/
-	if ((name[nlen-1] == '_' && name[nlen-2] == '_') 
-	    || strchr(name, '.')) {
-		Py_INCREF(ident);
-		return ident; /* Don't mangle __whatever__ */
-	}
-	/* Strip leading underscores from class name */
-	while (*p == '_')
-		p++;
-	if (*p == '\0') {
-		Py_INCREF(ident);
-		return ident; /* Don't mangle if class is just underscores */
-	}
-	plen = strlen(p);
-
-	assert(1 <= PY_SSIZE_T_MAX - nlen);
-	assert(1 + nlen <= PY_SSIZE_T_MAX - plen);
-
-	ident = PyString_FromStringAndSize(NULL, 1 + nlen + plen);
-	if (!ident)
-		return 0;
-	/* ident = "_" + p[:plen] + name # i.e. 1+plen+nlen bytes */
-	buffer = PyString_AS_STRING(ident);
-	buffer[0] = '_';
-	strncpy(buffer+1, p, plen);
-	strcpy(buffer+1+plen, name);
-	return ident;
+    /* Name mangling: __private becomes _classname__private.
+       This is independent from how the name is used. */
+    const char *p, *name = PyString_AsString(ident);
+    char *buffer;
+    size_t nlen, plen;
+    if (privateobj == NULL || !PyString_Check(privateobj) ||
+        name == NULL || name[0] != '_' || name[1] != '_') {
+        Py_INCREF(ident);
+        return ident;
+    }
+    p = PyString_AsString(privateobj);
+    nlen = strlen(name);
+    /* Don't mangle __id__ or names with dots.
+
+       The only time a name with a dot can occur is when
+       we are compiling an import statement that has a
+       package name.
+
+       TODO(jhylton): Decide whether we want to support
+       mangling of the module name, e.g. __M.X.
+    */
+    if ((name[nlen-1] == '_' && name[nlen-2] == '_')
+        || strchr(name, '.')) {
+        Py_INCREF(ident);
+        return ident; /* Don't mangle __whatever__ */
+    }
+    /* Strip leading underscores from class name */
+    while (*p == '_')
+        p++;
+    if (*p == '\0') {
+        Py_INCREF(ident);
+        return ident; /* Don't mangle if class is just underscores */
+    }
+    plen = strlen(p);
+
+    assert(1 <= PY_SSIZE_T_MAX - nlen);
+    assert(1 + nlen <= PY_SSIZE_T_MAX - plen);
+
+    ident = PyString_FromStringAndSize(NULL, 1 + nlen + plen);
+    if (!ident)
+        return 0;
+    /* ident = "_" + p[:plen] + name # i.e. 1+plen+nlen bytes */
+    buffer = PyString_AS_STRING(ident);
+    buffer[0] = '_';
+    strncpy(buffer+1, p, plen);
+    strcpy(buffer+1+plen, name);
+    return ident;
 }
 
 static int
 compiler_init(struct compiler *c)
 {
-	memset(c, 0, sizeof(struct compiler));
+    memset(c, 0, sizeof(struct compiler));
 
-	c->c_stack = PyList_New(0);
-	if (!c->c_stack)
-		return 0;
+    c->c_stack = PyList_New(0);
+    if (!c->c_stack)
+        return 0;
 
-	return 1;
+    return 1;
 }
 
 PyCodeObject *
 PyAST_Compile(mod_ty mod, const char *filename, PyCompilerFlags *flags,
-	      PyArena *arena)
-{
-	struct compiler c;
-	PyCodeObject *co = NULL;
-	PyCompilerFlags local_flags;
-	int merged;
-
-	if (!__doc__) {
-		__doc__ = PyString_InternFromString("__doc__");
-		if (!__doc__)
-			return NULL;
-	}
-
-	if (!compiler_init(&c))
-		return NULL;
-	c.c_filename = filename;
-	c.c_arena = arena;
-	c.c_future = PyFuture_FromAST(mod, filename);
-	if (c.c_future == NULL)
-		goto finally;
-	if (!flags) {
-		local_flags.cf_flags = 0;
-		flags = &local_flags;
-	}
-	merged = c.c_future->ff_features | flags->cf_flags;
-	c.c_future->ff_features = merged;
-	flags->cf_flags = merged;
-	c.c_flags = flags;
-	c.c_nestlevel = 0;
-
-	c.c_st = PySymtable_Build(mod, filename, c.c_future);
-	if (c.c_st == NULL) {
-		if (!PyErr_Occurred())
-			PyErr_SetString(PyExc_SystemError, "no symtable");
-		goto finally;
-	}
-
-	co = compiler_mod(&c, mod);
+              PyArena *arena)
+{
+    struct compiler c;
+    PyCodeObject *co = NULL;
+    PyCompilerFlags local_flags;
+    int merged;
+
+    if (!__doc__) {
+        __doc__ = PyString_InternFromString("__doc__");
+        if (!__doc__)
+            return NULL;
+    }
+
+    if (!compiler_init(&c))
+        return NULL;
+    c.c_filename = filename;
+    c.c_arena = arena;
+    c.c_future = PyFuture_FromAST(mod, filename);
+    if (c.c_future == NULL)
+        goto finally;
+    if (!flags) {
+        local_flags.cf_flags = 0;
+        flags = &local_flags;
+    }
+    merged = c.c_future->ff_features | flags->cf_flags;
+    c.c_future->ff_features = merged;
+    flags->cf_flags = merged;
+    c.c_flags = flags;
+    c.c_nestlevel = 0;
+
+    c.c_st = PySymtable_Build(mod, filename, c.c_future);
+    if (c.c_st == NULL) {
+        if (!PyErr_Occurred())
+            PyErr_SetString(PyExc_SystemError, "no symtable");
+        goto finally;
+    }
+
+    co = compiler_mod(&c, mod);
 
  finally:
-	compiler_free(&c);
-	assert(co || PyErr_Occurred());
-	return co;
+    compiler_free(&c);
+    assert(co || PyErr_Occurred());
+    return co;
 }
 
 PyCodeObject *
 PyNode_Compile(struct _node *n, const char *filename)
 {
-	PyCodeObject *co = NULL;
-	mod_ty mod;
-	PyArena *arena = PyArena_New();
-	if (!arena)
-		return NULL;
-	mod = PyAST_FromNode(n, NULL, filename, arena);
-	if (mod)
-		co = PyAST_Compile(mod, filename, NULL, arena);
-	PyArena_Free(arena);
-	return co;
+    PyCodeObject *co = NULL;
+    mod_ty mod;
+    PyArena *arena = PyArena_New();
+    if (!arena)
+        return NULL;
+    mod = PyAST_FromNode(n, NULL, filename, arena);
+    if (mod)
+        co = PyAST_Compile(mod, filename, NULL, arena);
+    PyArena_Free(arena);
+    return co;
 }
 
 static void
 compiler_free(struct compiler *c)
 {
-	if (c->c_st)
-		PySymtable_Free(c->c_st);
-	if (c->c_future)
-		PyObject_Free(c->c_future);
-	Py_DECREF(c->c_stack);
+    if (c->c_st)
+        PySymtable_Free(c->c_st);
+    if (c->c_future)
+        PyObject_Free(c->c_future);
+    Py_DECREF(c->c_stack);
 }
 
 static PyObject *
 list2dict(PyObject *list)
 {
-	Py_ssize_t i, n;
-	PyObject *v, *k;
-	PyObject *dict = PyDict_New();
-	if (!dict) return NULL;
-
-	n = PyList_Size(list);
-	for (i = 0; i < n; i++) {
-		v = PyInt_FromLong(i);
-		if (!v) {
-			Py_DECREF(dict);
-			return NULL;
-		}
-		k = PyList_GET_ITEM(list, i);
-		k = PyTuple_Pack(2, k, k->ob_type);
-		if (k == NULL || PyDict_SetItem(dict, k, v) < 0) {
-			Py_XDECREF(k);
-			Py_DECREF(v);
-			Py_DECREF(dict);
-			return NULL;
-		}
-		Py_DECREF(k);
-		Py_DECREF(v);
-	}
-	return dict;
+    Py_ssize_t i, n;
+    PyObject *v, *k;
+    PyObject *dict = PyDict_New();
+    if (!dict) return NULL;
+
+    n = PyList_Size(list);
+    for (i = 0; i < n; i++) {
+        v = PyInt_FromLong(i);
+        if (!v) {
+            Py_DECREF(dict);
+            return NULL;
+        }
+        k = PyList_GET_ITEM(list, i);
+        k = PyTuple_Pack(2, k, k->ob_type);
+        if (k == NULL || PyDict_SetItem(dict, k, v) < 0) {
+            Py_XDECREF(k);
+            Py_DECREF(v);
+            Py_DECREF(dict);
+            return NULL;
+        }
+        Py_DECREF(k);
+        Py_DECREF(v);
+    }
+    return dict;
 }
 
 /* Return new dict containing names from src that match scope(s).
 
 src is a symbol table dictionary.  If the scope of a name matches
-either scope_type or flag is set, insert it into the new dict.	The
+either scope_type or flag is set, insert it into the new dict.  The
 values are integers, starting at offset and increasing by one for
 each key.
 */
@@ -359,179 +359,179 @@ each key.
 static PyObject *
 dictbytype(PyObject *src, int scope_type, int flag, int offset)
 {
-	Py_ssize_t pos = 0, i = offset, scope;
-	PyObject *k, *v, *dest = PyDict_New();
-
-	assert(offset >= 0);
-	if (dest == NULL)
-		return NULL;
-
-	while (PyDict_Next(src, &pos, &k, &v)) {
-		/* XXX this should probably be a macro in symtable.h */
-		assert(PyInt_Check(v));
-		scope = (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK;
-
-		if (scope == scope_type || PyInt_AS_LONG(v) & flag) {
-			PyObject *tuple, *item = PyInt_FromLong(i);
-			if (item == NULL) {
-				Py_DECREF(dest);
-				return NULL;
-			}
-			i++;
-			tuple = PyTuple_Pack(2, k, k->ob_type);
-			if (!tuple || PyDict_SetItem(dest, tuple, item) < 0) {
-				Py_DECREF(item);
-				Py_DECREF(dest);
-				Py_XDECREF(tuple);
-				return NULL;
-			}
-			Py_DECREF(item);
-			Py_DECREF(tuple);
-		}
-	}
-	return dest;
+    Py_ssize_t pos = 0, i = offset, scope;
+    PyObject *k, *v, *dest = PyDict_New();
+
+    assert(offset >= 0);
+    if (dest == NULL)
+        return NULL;
+
+    while (PyDict_Next(src, &pos, &k, &v)) {
+        /* XXX this should probably be a macro in symtable.h */
+        assert(PyInt_Check(v));
+        scope = (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK;
+
+        if (scope == scope_type || PyInt_AS_LONG(v) & flag) {
+            PyObject *tuple, *item = PyInt_FromLong(i);
+            if (item == NULL) {
+                Py_DECREF(dest);
+                return NULL;
+            }
+            i++;
+            tuple = PyTuple_Pack(2, k, k->ob_type);
+            if (!tuple || PyDict_SetItem(dest, tuple, item) < 0) {
+                Py_DECREF(item);
+                Py_DECREF(dest);
+                Py_XDECREF(tuple);
+                return NULL;
+            }
+            Py_DECREF(item);
+            Py_DECREF(tuple);
+        }
+    }
+    return dest;
 }
 
 static void
 compiler_unit_check(struct compiler_unit *u)
 {
-	basicblock *block;
-	for (block = u->u_blocks; block != NULL; block = block->b_list) {
-		assert((void *)block != (void *)0xcbcbcbcb);
-		assert((void *)block != (void *)0xfbfbfbfb);
-		assert((void *)block != (void *)0xdbdbdbdb);
-		if (block->b_instr != NULL) {
-			assert(block->b_ialloc > 0);
-			assert(block->b_iused > 0);
-			assert(block->b_ialloc >= block->b_iused);
-		}
-		else {
-			assert (block->b_iused == 0);
-			assert (block->b_ialloc == 0);
-		}
-	}
+    basicblock *block;
+    for (block = u->u_blocks; block != NULL; block = block->b_list) {
+        assert((void *)block != (void *)0xcbcbcbcb);
+        assert((void *)block != (void *)0xfbfbfbfb);
+        assert((void *)block != (void *)0xdbdbdbdb);
+        if (block->b_instr != NULL) {
+            assert(block->b_ialloc > 0);
+            assert(block->b_iused > 0);
+            assert(block->b_ialloc >= block->b_iused);
+        }
+        else {
+            assert (block->b_iused == 0);
+            assert (block->b_ialloc == 0);
+        }
+    }
 }
 
 static void
 compiler_unit_free(struct compiler_unit *u)
 {
-	basicblock *b, *next;
-
-	compiler_unit_check(u);
-	b = u->u_blocks;
-	while (b != NULL) {
-		if (b->b_instr)
-			PyObject_Free((void *)b->b_instr);
-		next = b->b_list;
-		PyObject_Free((void *)b);
-		b = next;
-	}
-	Py_CLEAR(u->u_ste);
-	Py_CLEAR(u->u_name);
-	Py_CLEAR(u->u_consts);
-	Py_CLEAR(u->u_names);
-	Py_CLEAR(u->u_varnames);
-	Py_CLEAR(u->u_freevars);
-	Py_CLEAR(u->u_cellvars);
-	Py_CLEAR(u->u_private);
-	PyObject_Free(u);
+    basicblock *b, *next;
+
+    compiler_unit_check(u);
+    b = u->u_blocks;
+    while (b != NULL) {
+        if (b->b_instr)
+            PyObject_Free((void *)b->b_instr);
+        next = b->b_list;
+        PyObject_Free((void *)b);
+        b = next;
+    }
+    Py_CLEAR(u->u_ste);
+    Py_CLEAR(u->u_name);
+    Py_CLEAR(u->u_consts);
+    Py_CLEAR(u->u_names);
+    Py_CLEAR(u->u_varnames);
+    Py_CLEAR(u->u_freevars);
+    Py_CLEAR(u->u_cellvars);
+    Py_CLEAR(u->u_private);
+    PyObject_Free(u);
 }
 
 static int
 compiler_enter_scope(struct compiler *c, identifier name, void *key,
-		     int lineno)
-{
-	struct compiler_unit *u;
-
-	u = (struct compiler_unit *)PyObject_Malloc(sizeof(
-						struct compiler_unit));
-	if (!u) {
-		PyErr_NoMemory();
-		return 0;
-	}
-	memset(u, 0, sizeof(struct compiler_unit));
-	u->u_argcount = 0;
-	u->u_ste = PySymtable_Lookup(c->c_st, key);
-	if (!u->u_ste) {
-		compiler_unit_free(u);
-		return 0;
-	}
-	Py_INCREF(name);
-	u->u_name = name;
-	u->u_varnames = list2dict(u->u_ste->ste_varnames);
-	u->u_cellvars = dictbytype(u->u_ste->ste_symbols, CELL, 0, 0);
-	if (!u->u_varnames || !u->u_cellvars) {
-		compiler_unit_free(u);
-		return 0;
-	}
-
-	u->u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS,
-				   PyDict_Size(u->u_cellvars));
-	if (!u->u_freevars) {
-		compiler_unit_free(u);
-		return 0;
-	}
-
-	u->u_blocks = NULL;
-	u->u_nfblocks = 0;
-	u->u_firstlineno = lineno;
-	u->u_lineno = 0;
-	u->u_lineno_set = false;
-	u->u_consts = PyDict_New();
-	if (!u->u_consts) {
-		compiler_unit_free(u);
-		return 0;
-	}
-	u->u_names = PyDict_New();
-	if (!u->u_names) {
-		compiler_unit_free(u);
-		return 0;
-	}
-
-	u->u_private = NULL;
-
-	/* Push the old compiler_unit on the stack. */
-	if (c->u) {
-		PyObject *capsule = PyCapsule_New(c->u, COMPILER_CAPSULE_NAME_COMPILER_UNIT, NULL);
-		if (!capsule || PyList_Append(c->c_stack, capsule) < 0) {
-			Py_XDECREF(capsule);
-			compiler_unit_free(u);
-			return 0;
-		}
-		Py_DECREF(capsule);
-		u->u_private = c->u->u_private;
-		Py_XINCREF(u->u_private);
-	}
-	c->u = u;
-
-	c->c_nestlevel++;
-	if (compiler_use_new_block(c) == NULL)
-		return 0;
-
-	return 1;
+                     int lineno)
+{
+    struct compiler_unit *u;
+
+    u = (struct compiler_unit *)PyObject_Malloc(sizeof(
+                                            struct compiler_unit));
+    if (!u) {
+        PyErr_NoMemory();
+        return 0;
+    }
+    memset(u, 0, sizeof(struct compiler_unit));
+    u->u_argcount = 0;
+    u->u_ste = PySymtable_Lookup(c->c_st, key);
+    if (!u->u_ste) {
+        compiler_unit_free(u);
+        return 0;
+    }
+    Py_INCREF(name);
+    u->u_name = name;
+    u->u_varnames = list2dict(u->u_ste->ste_varnames);
+    u->u_cellvars = dictbytype(u->u_ste->ste_symbols, CELL, 0, 0);
+    if (!u->u_varnames || !u->u_cellvars) {
+        compiler_unit_free(u);
+        return 0;
+    }
+
+    u->u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS,
+                               PyDict_Size(u->u_cellvars));
+    if (!u->u_freevars) {
+        compiler_unit_free(u);
+        return 0;
+    }
+
+    u->u_blocks = NULL;
+    u->u_nfblocks = 0;
+    u->u_firstlineno = lineno;
+    u->u_lineno = 0;
+    u->u_lineno_set = false;
+    u->u_consts = PyDict_New();
+    if (!u->u_consts) {
+        compiler_unit_free(u);
+        return 0;
+    }
+    u->u_names = PyDict_New();
+    if (!u->u_names) {
+        compiler_unit_free(u);
+        return 0;
+    }
+
+    u->u_private = NULL;
+
+    /* Push the old compiler_unit on the stack. */
+    if (c->u) {
+        PyObject *capsule = PyCapsule_New(c->u, COMPILER_CAPSULE_NAME_COMPILER_UNIT, NULL);
+        if (!capsule || PyList_Append(c->c_stack, capsule) < 0) {
+            Py_XDECREF(capsule);
+            compiler_unit_free(u);
+            return 0;
+        }
+        Py_DECREF(capsule);
+        u->u_private = c->u->u_private;
+        Py_XINCREF(u->u_private);
+    }
+    c->u = u;
+
+    c->c_nestlevel++;
+    if (compiler_use_new_block(c) == NULL)
+        return 0;
+
+    return 1;
 }
 
 static void
 compiler_exit_scope(struct compiler *c)
 {
-	int n;
-	PyObject *capsule;
-
-	c->c_nestlevel--;
-	compiler_unit_free(c->u);
-	/* Restore c->u to the parent unit. */
-	n = PyList_GET_SIZE(c->c_stack) - 1;
-	if (n >= 0) {
-		capsule = PyList_GET_ITEM(c->c_stack, n);
-		c->u = (struct compiler_unit *)PyCapsule_GetPointer(capsule, COMPILER_CAPSULE_NAME_COMPILER_UNIT);
-		assert(c->u);
-		/* we are deleting from a list so this really shouldn't fail */
-		if (PySequence_DelItem(c->c_stack, n) < 0)
-			Py_FatalError("compiler_exit_scope()");
-		compiler_unit_check(c->u);
-	}
-	else
-		c->u = NULL;
+    int n;
+    PyObject *capsule;
+
+    c->c_nestlevel--;
+    compiler_unit_free(c->u);
+    /* Restore c->u to the parent unit. */
+    n = PyList_GET_SIZE(c->c_stack) - 1;
+    if (n >= 0) {
+        capsule = PyList_GET_ITEM(c->c_stack, n);
+        c->u = (struct compiler_unit *)PyCapsule_GetPointer(capsule, COMPILER_CAPSULE_NAME_COMPILER_UNIT);
+        assert(c->u);
+        /* we are deleting from a list so this really shouldn't fail */
+        if (PySequence_DelItem(c->c_stack, n) < 0)
+            Py_FatalError("compiler_exit_scope()");
+        compiler_unit_check(c->u);
+    }
+    else
+        c->u = NULL;
 
 }
 
@@ -542,50 +542,50 @@ compiler_exit_scope(struct compiler *c)
 static basicblock *
 compiler_new_block(struct compiler *c)
 {
-	basicblock *b;
-	struct compiler_unit *u;
+    basicblock *b;
+    struct compiler_unit *u;
 
-	u = c->u;
-	b = (basicblock *)PyObject_Malloc(sizeof(basicblock));
-	if (b == NULL) {
-		PyErr_NoMemory();
-		return NULL;
-	}
-	memset((void *)b, 0, sizeof(basicblock));
-	/* Extend the singly linked list of blocks with new block. */
-	b->b_list = u->u_blocks;
-	u->u_blocks = b;
-	return b;
+    u = c->u;
+    b = (basicblock *)PyObject_Malloc(sizeof(basicblock));
+    if (b == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    memset((void *)b, 0, sizeof(basicblock));
+    /* Extend the singly linked list of blocks with new block. */
+    b->b_list = u->u_blocks;
+    u->u_blocks = b;
+    return b;
 }
 
 static basicblock *
 compiler_use_new_block(struct compiler *c)
 {
-	basicblock *block = compiler_new_block(c);
-	if (block == NULL)
-		return NULL;
-	c->u->u_curblock = block;
-	return block;
+    basicblock *block = compiler_new_block(c);
+    if (block == NULL)
+        return NULL;
+    c->u->u_curblock = block;
+    return block;
 }
 
 static basicblock *
 compiler_next_block(struct compiler *c)
 {
-	basicblock *block = compiler_new_block(c);
-	if (block == NULL)
-		return NULL;
-	c->u->u_curblock->b_next = block;
-	c->u->u_curblock = block;
-	return block;
+    basicblock *block = compiler_new_block(c);
+    if (block == NULL)
+        return NULL;
+    c->u->u_curblock->b_next = block;
+    c->u->u_curblock = block;
+    return block;
 }
 
 static basicblock *
 compiler_use_next_block(struct compiler *c, basicblock *block)
 {
-	assert(block != NULL);
-	c->u->u_curblock->b_next = block;
-	c->u->u_curblock = block;
-	return block;
+    assert(block != NULL);
+    c->u->u_curblock->b_next = block;
+    c->u->u_curblock = block;
+    return block;
 }
 
 /* Returns the offset of the next instruction in the current block's
@@ -596,44 +596,44 @@ compiler_use_next_block(struct compiler *c, basicblock *block)
 static int
 compiler_next_instr(struct compiler *c, basicblock *b)
 {
-	assert(b != NULL);
-	if (b->b_instr == NULL) {
-		b->b_instr = (struct instr *)PyObject_Malloc(
-				 sizeof(struct instr) * DEFAULT_BLOCK_SIZE);
-		if (b->b_instr == NULL) {
-			PyErr_NoMemory();
-			return -1;
-		}
-		b->b_ialloc = DEFAULT_BLOCK_SIZE;
-		memset((char *)b->b_instr, 0,
-		       sizeof(struct instr) * DEFAULT_BLOCK_SIZE);
-	}
-	else if (b->b_iused == b->b_ialloc) {
-		struct instr *tmp;
-		size_t oldsize, newsize;
-		oldsize = b->b_ialloc * sizeof(struct instr);
-		newsize = oldsize << 1;
-
-		if (oldsize > (PY_SIZE_MAX >> 1)) {
-			PyErr_NoMemory();
-			return -1;
-		}
-
-		if (newsize == 0) {
-			PyErr_NoMemory();
-			return -1;
-		}
-		b->b_ialloc <<= 1;
-		tmp = (struct instr *)PyObject_Realloc(
-						(void *)b->b_instr, newsize);
-		if (tmp == NULL) {
-			PyErr_NoMemory();
-			return -1;
-		}
-		b->b_instr = tmp;
-		memset((char *)b->b_instr + oldsize, 0, newsize - oldsize);
-	}
-	return b->b_iused++;
+    assert(b != NULL);
+    if (b->b_instr == NULL) {
+        b->b_instr = (struct instr *)PyObject_Malloc(
+                         sizeof(struct instr) * DEFAULT_BLOCK_SIZE);
+        if (b->b_instr == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        b->b_ialloc = DEFAULT_BLOCK_SIZE;
+        memset((char *)b->b_instr, 0,
+               sizeof(struct instr) * DEFAULT_BLOCK_SIZE);
+    }
+    else if (b->b_iused == b->b_ialloc) {
+        struct instr *tmp;
+        size_t oldsize, newsize;
+        oldsize = b->b_ialloc * sizeof(struct instr);
+        newsize = oldsize << 1;
+
+        if (oldsize > (PY_SIZE_MAX >> 1)) {
+            PyErr_NoMemory();
+            return -1;
+        }
+
+        if (newsize == 0) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        b->b_ialloc <<= 1;
+        tmp = (struct instr *)PyObject_Realloc(
+                                        (void *)b->b_instr, newsize);
+        if (tmp == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        b->b_instr = tmp;
+        memset((char *)b->b_instr + oldsize, 0, newsize - oldsize);
+    }
+    return b->b_iused++;
 }
 
 /* Set the i_lineno member of the instruction at offset off if the
@@ -651,246 +651,246 @@ compiler_next_instr(struct compiler *c, basicblock *b)
 static void
 compiler_set_lineno(struct compiler *c, int off)
 {
-	basicblock *b;
-	if (c->u->u_lineno_set)
-		return;
-	c->u->u_lineno_set = true;
-	b = c->u->u_curblock;
-	b->b_instr[off].i_lineno = c->u->u_lineno;
+    basicblock *b;
+    if (c->u->u_lineno_set)
+        return;
+    c->u->u_lineno_set = true;
+    b = c->u->u_curblock;
+    b->b_instr[off].i_lineno = c->u->u_lineno;
 }
 
 static int
 opcode_stack_effect(int opcode, int oparg)
 {
-	switch (opcode) {
-		case POP_TOP:
-			return -1;
-		case ROT_TWO:
-		case ROT_THREE:
-			return 0;
-		case DUP_TOP:
-			return 1;
-		case ROT_FOUR:
-			return 0;
-
-		case UNARY_POSITIVE:
-		case UNARY_NEGATIVE:
-		case UNARY_NOT:
-		case UNARY_CONVERT:
-		case UNARY_INVERT:
-			return 0;
-
-		case SET_ADD:
-		case LIST_APPEND:
-			return -1;
-
-		case MAP_ADD:
-			return -2;
-
-		case BINARY_POWER:
-		case BINARY_MULTIPLY:
-		case BINARY_DIVIDE:
-		case BINARY_MODULO:
-		case BINARY_ADD:
-		case BINARY_SUBTRACT:
-		case BINARY_SUBSCR:
-		case BINARY_FLOOR_DIVIDE:
-		case BINARY_TRUE_DIVIDE:
-			return -1;
-		case INPLACE_FLOOR_DIVIDE:
-		case INPLACE_TRUE_DIVIDE:
-			return -1;
-
-		case SLICE+0:
-			return 0;
-		case SLICE+1:
-			return -1;
-		case SLICE+2:
-			return -1;
-		case SLICE+3:
-			return -2;
-
-		case STORE_SLICE+0:
-			return -2;
-		case STORE_SLICE+1:
-			return -3;
-		case STORE_SLICE+2:
-			return -3;
-		case STORE_SLICE+3:
-			return -4;
-
-		case DELETE_SLICE+0:
-			return -1;
-		case DELETE_SLICE+1:
-			return -2;
-		case DELETE_SLICE+2:
-			return -2;
-		case DELETE_SLICE+3:
-			return -3;
-
-		case INPLACE_ADD:
-		case INPLACE_SUBTRACT:
-		case INPLACE_MULTIPLY:
-		case INPLACE_DIVIDE:
-		case INPLACE_MODULO:
-			return -1;
-		case STORE_SUBSCR:
-			return -3;
-		case STORE_MAP:
-			return -2;
-		case DELETE_SUBSCR:
-			return -2;
-
-		case BINARY_LSHIFT:
-		case BINARY_RSHIFT:
-		case BINARY_AND:
-		case BINARY_XOR:
-		case BINARY_OR:
-			return -1;
-		case INPLACE_POWER:
-			return -1;
-		case GET_ITER:
-			return 0;
-
-		case PRINT_EXPR:
-			return -1;
-		case PRINT_ITEM:
-			return -1;
-		case PRINT_NEWLINE:
-			return 0;
-		case PRINT_ITEM_TO:
-			return -2;
-		case PRINT_NEWLINE_TO:
-			return -1;
-		case INPLACE_LSHIFT:
-		case INPLACE_RSHIFT:
-		case INPLACE_AND:
-		case INPLACE_XOR:
-		case INPLACE_OR:
-			return -1;
-		case BREAK_LOOP:
-			return 0;
-	        case SETUP_WITH:
-			return 4;
-		case WITH_CLEANUP:
-			return -1; /* XXX Sometimes more */
-		case LOAD_LOCALS:
-			return 1;
-		case RETURN_VALUE:
-			return -1;
-		case IMPORT_STAR:
-			return -1;
-		case EXEC_STMT:
-			return -3;
-		case YIELD_VALUE:
-			return 0;
-
-		case POP_BLOCK:
-			return 0;
-		case END_FINALLY:
-			return -3; /* or -1 or -2 if no exception occurred or
-				      return/break/continue */
-		case BUILD_CLASS:
-			return -2;
-
-		case STORE_NAME:
-			return -1;
-		case DELETE_NAME:
-			return 0;
-		case UNPACK_SEQUENCE:
-			return oparg-1;
-		case FOR_ITER:
-			return 1; /* or -1, at end of iterator */
-
-		case STORE_ATTR:
-			return -2;
-		case DELETE_ATTR:
-			return -1;
-		case STORE_GLOBAL:
-			return -1;
-		case DELETE_GLOBAL:
-			return 0;
-		case DUP_TOPX:
-			return oparg;
-		case LOAD_CONST:
-			return 1;
-		case LOAD_NAME:
-			return 1;
-		case BUILD_TUPLE:
-		case BUILD_LIST:
-		case BUILD_SET:
-			return 1-oparg;
-		case BUILD_MAP:
-			return 1;
-		case LOAD_ATTR:
-			return 0;
-		case COMPARE_OP:
-			return -1;
-		case IMPORT_NAME:
-			return -1;
-		case IMPORT_FROM:
-			return 1;
-
-		case JUMP_FORWARD:
-		case JUMP_IF_TRUE_OR_POP:  /* -1 if jump not taken */
-		case JUMP_IF_FALSE_OR_POP:  /*  "" */
-		case JUMP_ABSOLUTE:
-			return 0;
-
-		case POP_JUMP_IF_FALSE:
-		case POP_JUMP_IF_TRUE:
-			return -1;
-
-		case LOAD_GLOBAL:
-			return 1;
-
-		case CONTINUE_LOOP:
-			return 0;
-		case SETUP_LOOP:
-		case SETUP_EXCEPT:
-		case SETUP_FINALLY:
-			return 0;
-
-		case LOAD_FAST:
-			return 1;
-		case STORE_FAST:
-			return -1;
-		case DELETE_FAST:
-			return 0;
-
-		case RAISE_VARARGS:
-			return -oparg;
+    switch (opcode) {
+        case POP_TOP:
+            return -1;
+        case ROT_TWO:
+        case ROT_THREE:
+            return 0;
+        case DUP_TOP:
+            return 1;
+        case ROT_FOUR:
+            return 0;
+
+        case UNARY_POSITIVE:
+        case UNARY_NEGATIVE:
+        case UNARY_NOT:
+        case UNARY_CONVERT:
+        case UNARY_INVERT:
+            return 0;
+
+        case SET_ADD:
+        case LIST_APPEND:
+            return -1;
+
+        case MAP_ADD:
+            return -2;
+
+        case BINARY_POWER:
+        case BINARY_MULTIPLY:
+        case BINARY_DIVIDE:
+        case BINARY_MODULO:
+        case BINARY_ADD:
+        case BINARY_SUBTRACT:
+        case BINARY_SUBSCR:
+        case BINARY_FLOOR_DIVIDE:
+        case BINARY_TRUE_DIVIDE:
+            return -1;
+        case INPLACE_FLOOR_DIVIDE:
+        case INPLACE_TRUE_DIVIDE:
+            return -1;
+
+        case SLICE+0:
+            return 0;
+        case SLICE+1:
+            return -1;
+        case SLICE+2:
+            return -1;
+        case SLICE+3:
+            return -2;
+
+        case STORE_SLICE+0:
+            return -2;
+        case STORE_SLICE+1:
+            return -3;
+        case STORE_SLICE+2:
+            return -3;
+        case STORE_SLICE+3:
+            return -4;
+
+        case DELETE_SLICE+0:
+            return -1;
+        case DELETE_SLICE+1:
+            return -2;
+        case DELETE_SLICE+2:
+            return -2;
+        case DELETE_SLICE+3:
+            return -3;
+
+        case INPLACE_ADD:
+        case INPLACE_SUBTRACT:
+        case INPLACE_MULTIPLY:
+        case INPLACE_DIVIDE:
+        case INPLACE_MODULO:
+            return -1;
+        case STORE_SUBSCR:
+            return -3;
+        case STORE_MAP:
+            return -2;
+        case DELETE_SUBSCR:
+            return -2;
+
+        case BINARY_LSHIFT:
+        case BINARY_RSHIFT:
+        case BINARY_AND:
+        case BINARY_XOR:
+        case BINARY_OR:
+            return -1;
+        case INPLACE_POWER:
+            return -1;
+        case GET_ITER:
+            return 0;
+
+        case PRINT_EXPR:
+            return -1;
+        case PRINT_ITEM:
+            return -1;
+        case PRINT_NEWLINE:
+            return 0;
+        case PRINT_ITEM_TO:
+            return -2;
+        case PRINT_NEWLINE_TO:
+            return -1;
+        case INPLACE_LSHIFT:
+        case INPLACE_RSHIFT:
+        case INPLACE_AND:
+        case INPLACE_XOR:
+        case INPLACE_OR:
+            return -1;
+        case BREAK_LOOP:
+            return 0;
+        case SETUP_WITH:
+            return 4;
+        case WITH_CLEANUP:
+            return -1; /* XXX Sometimes more */
+        case LOAD_LOCALS:
+            return 1;
+        case RETURN_VALUE:
+            return -1;
+        case IMPORT_STAR:
+            return -1;
+        case EXEC_STMT:
+            return -3;
+        case YIELD_VALUE:
+            return 0;
+
+        case POP_BLOCK:
+            return 0;
+        case END_FINALLY:
+            return -3; /* or -1 or -2 if no exception occurred or
+                          return/break/continue */
+        case BUILD_CLASS:
+            return -2;
+
+        case STORE_NAME:
+            return -1;
+        case DELETE_NAME:
+            return 0;
+        case UNPACK_SEQUENCE:
+            return oparg-1;
+        case FOR_ITER:
+            return 1; /* or -1, at end of iterator */
+
+        case STORE_ATTR:
+            return -2;
+        case DELETE_ATTR:
+            return -1;
+        case STORE_GLOBAL:
+            return -1;
+        case DELETE_GLOBAL:
+            return 0;
+        case DUP_TOPX:
+            return oparg;
+        case LOAD_CONST:
+            return 1;
+        case LOAD_NAME:
+            return 1;
+        case BUILD_TUPLE:
+        case BUILD_LIST:
+        case BUILD_SET:
+            return 1-oparg;
+        case BUILD_MAP:
+            return 1;
+        case LOAD_ATTR:
+            return 0;
+        case COMPARE_OP:
+            return -1;
+        case IMPORT_NAME:
+            return -1;
+        case IMPORT_FROM:
+            return 1;
+
+        case JUMP_FORWARD:
+        case JUMP_IF_TRUE_OR_POP:  /* -1 if jump not taken */
+        case JUMP_IF_FALSE_OR_POP:  /*  "" */
+        case JUMP_ABSOLUTE:
+            return 0;
+
+        case POP_JUMP_IF_FALSE:
+        case POP_JUMP_IF_TRUE:
+            return -1;
+
+        case LOAD_GLOBAL:
+            return 1;
+
+        case CONTINUE_LOOP:
+            return 0;
+        case SETUP_LOOP:
+        case SETUP_EXCEPT:
+        case SETUP_FINALLY:
+            return 0;
+
+        case LOAD_FAST:
+            return 1;
+        case STORE_FAST:
+            return -1;
+        case DELETE_FAST:
+            return 0;
+
+        case RAISE_VARARGS:
+            return -oparg;
 #define NARGS(o) (((o) % 256) + 2*((o) / 256))
-		case CALL_FUNCTION:
-			return -NARGS(oparg);
-		case CALL_FUNCTION_VAR:
-		case CALL_FUNCTION_KW:
-			return -NARGS(oparg)-1;
-		case CALL_FUNCTION_VAR_KW:
-			return -NARGS(oparg)-2;
+        case CALL_FUNCTION:
+            return -NARGS(oparg);
+        case CALL_FUNCTION_VAR:
+        case CALL_FUNCTION_KW:
+            return -NARGS(oparg)-1;
+        case CALL_FUNCTION_VAR_KW:
+            return -NARGS(oparg)-2;
 #undef NARGS
-		case MAKE_FUNCTION:
-			return -oparg;
-		case BUILD_SLICE:
-			if (oparg == 3)
-				return -2;
-			else
-				return -1;
-
-		case MAKE_CLOSURE:
-			return -oparg-1;
-		case LOAD_CLOSURE:
-			return 1;
-		case LOAD_DEREF:
-			return 1;
-		case STORE_DEREF:
-			return -1;
-		default:
-			fprintf(stderr, "opcode = %d\n", opcode);
-			Py_FatalError("opcode_stack_effect()");
-
-	}
-	return 0; /* not reachable */
+        case MAKE_FUNCTION:
+            return -oparg;
+        case BUILD_SLICE:
+            if (oparg == 3)
+                return -2;
+            else
+                return -1;
+
+        case MAKE_CLOSURE:
+            return -oparg-1;
+        case LOAD_CLOSURE:
+            return 1;
+        case LOAD_DEREF:
+            return 1;
+        case STORE_DEREF:
+            return -1;
+        default:
+            fprintf(stderr, "opcode = %d\n", opcode);
+            Py_FatalError("opcode_stack_effect()");
+
+    }
+    return 0; /* not reachable */
 }
 
 /* Add an opcode with no argument.
@@ -900,116 +900,116 @@ opcode_stack_effect(int opcode, int oparg)
 static int
 compiler_addop(struct compiler *c, int opcode)
 {
-	basicblock *b;
-	struct instr *i;
-	int off;
-	off = compiler_next_instr(c, c->u->u_curblock);
-	if (off < 0)
-		return 0;
-	b = c->u->u_curblock;
-	i = &b->b_instr[off];
-	i->i_opcode = opcode;
-	i->i_hasarg = 0;
-	if (opcode == RETURN_VALUE)
-		b->b_return = 1;
-	compiler_set_lineno(c, off);
-	return 1;
+    basicblock *b;
+    struct instr *i;
+    int off;
+    off = compiler_next_instr(c, c->u->u_curblock);
+    if (off < 0)
+        return 0;
+    b = c->u->u_curblock;
+    i = &b->b_instr[off];
+    i->i_opcode = opcode;
+    i->i_hasarg = 0;
+    if (opcode == RETURN_VALUE)
+        b->b_return = 1;
+    compiler_set_lineno(c, off);
+    return 1;
 }
 
 static int
 compiler_add_o(struct compiler *c, PyObject *dict, PyObject *o)
 {
-	PyObject *t, *v;
-	Py_ssize_t arg;
-	double d;
-
-	/* necessary to make sure types aren't coerced (e.g., int and long) */
-        /* _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms */
-        if (PyFloat_Check(o)) {
-		d = PyFloat_AS_DOUBLE(o);
-		/* all we need is to make the tuple different in either the 0.0
-		 * or -0.0 case from all others, just to avoid the "coercion".
-		 */
-		if (d == 0.0 && copysign(1.0, d) < 0.0)
-			t = PyTuple_Pack(3, o, o->ob_type, Py_None);
-		else
-			t = PyTuple_Pack(2, o, o->ob_type);
-	}
+    PyObject *t, *v;
+    Py_ssize_t arg;
+    double d;
+
+    /* necessary to make sure types aren't coerced (e.g., int and long) */
+    /* _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms */
+    if (PyFloat_Check(o)) {
+        d = PyFloat_AS_DOUBLE(o);
+        /* all we need is to make the tuple different in either the 0.0
+         * or -0.0 case from all others, just to avoid the "coercion".
+         */
+        if (d == 0.0 && copysign(1.0, d) < 0.0)
+            t = PyTuple_Pack(3, o, o->ob_type, Py_None);
+        else
+            t = PyTuple_Pack(2, o, o->ob_type);
+    }
 #ifndef WITHOUT_COMPLEX
-	else if (PyComplex_Check(o)) {
-		Py_complex z;
-		int real_negzero, imag_negzero;
-		/* For the complex case we must make complex(x, 0.)
-		   different from complex(x, -0.) and complex(0., y)
-		   different from complex(-0., y), for any x and y.
-		   All four complex zeros must be distinguished.*/
-		z = PyComplex_AsCComplex(o);
-		real_negzero = z.real == 0.0 && copysign(1.0, z.real) < 0.0;
-		imag_negzero = z.imag == 0.0 && copysign(1.0, z.imag) < 0.0;
-		if (real_negzero && imag_negzero) {
-			t = PyTuple_Pack(5, o, o->ob_type,
-					 Py_None, Py_None, Py_None);
-		}
-		else if (imag_negzero) {
-			t = PyTuple_Pack(4, o, o->ob_type, Py_None, Py_None);
-		}
-		else if (real_negzero) {
-			t = PyTuple_Pack(3, o, o->ob_type, Py_None);
-		}
-		else {
-			t = PyTuple_Pack(2, o, o->ob_type);
-		}
+    else if (PyComplex_Check(o)) {
+        Py_complex z;
+        int real_negzero, imag_negzero;
+        /* For the complex case we must make complex(x, 0.)
+           different from complex(x, -0.) and complex(0., y)
+           different from complex(-0., y), for any x and y.
+           All four complex zeros must be distinguished.*/
+        z = PyComplex_AsCComplex(o);
+        real_negzero = z.real == 0.0 && copysign(1.0, z.real) < 0.0;
+        imag_negzero = z.imag == 0.0 && copysign(1.0, z.imag) < 0.0;
+        if (real_negzero && imag_negzero) {
+            t = PyTuple_Pack(5, o, o->ob_type,
+                             Py_None, Py_None, Py_None);
         }
+        else if (imag_negzero) {
+            t = PyTuple_Pack(4, o, o->ob_type, Py_None, Py_None);
+        }
+        else if (real_negzero) {
+            t = PyTuple_Pack(3, o, o->ob_type, Py_None);
+        }
+        else {
+            t = PyTuple_Pack(2, o, o->ob_type);
+        }
+    }
 #endif /* WITHOUT_COMPLEX */
-	else {
-		t = PyTuple_Pack(2, o, o->ob_type);
-        }
-	if (t == NULL)
-		return -1;
-
-	v = PyDict_GetItem(dict, t);
-	if (!v) {
-		arg = PyDict_Size(dict);
-		v = PyInt_FromLong(arg);
-		if (!v) {
-			Py_DECREF(t);
-			return -1;
-		}
-		if (PyDict_SetItem(dict, t, v) < 0) {
-			Py_DECREF(t);
-			Py_DECREF(v);
-			return -1;
-		}
-		Py_DECREF(v);
-	}
-	else
-		arg = PyInt_AsLong(v);
-	Py_DECREF(t);
-	return arg;
+    else {
+        t = PyTuple_Pack(2, o, o->ob_type);
+    }
+    if (t == NULL)
+        return -1;
+
+    v = PyDict_GetItem(dict, t);
+    if (!v) {
+        arg = PyDict_Size(dict);
+        v = PyInt_FromLong(arg);
+        if (!v) {
+            Py_DECREF(t);
+            return -1;
+        }
+        if (PyDict_SetItem(dict, t, v) < 0) {
+            Py_DECREF(t);
+            Py_DECREF(v);
+            return -1;
+        }
+        Py_DECREF(v);
+    }
+    else
+        arg = PyInt_AsLong(v);
+    Py_DECREF(t);
+    return arg;
 }
 
 static int
 compiler_addop_o(struct compiler *c, int opcode, PyObject *dict,
-		     PyObject *o)
+                     PyObject *o)
 {
     int arg = compiler_add_o(c, dict, o);
     if (arg < 0)
-	return 0;
+    return 0;
     return compiler_addop_i(c, opcode, arg);
 }
 
 static int
 compiler_addop_name(struct compiler *c, int opcode, PyObject *dict,
-		    PyObject *o)
+                    PyObject *o)
 {
     int arg;
     PyObject *mangled = _Py_Mangle(c->u->u_private, o);
     if (!mangled)
-	return 0;
+    return 0;
     arg = compiler_add_o(c, dict, mangled);
     Py_DECREF(mangled);
     if (arg < 0)
-	return 0;
+    return 0;
     return compiler_addop_i(c, opcode, arg);
 }
 
@@ -1020,43 +1020,43 @@ compiler_addop_name(struct compiler *c, int opcode, PyObject *dict,
 static int
 compiler_addop_i(struct compiler *c, int opcode, int oparg)
 {
-	struct instr *i;
-	int off;
-	off = compiler_next_instr(c, c->u->u_curblock);
-	if (off < 0)
-		return 0;
-	i = &c->u->u_curblock->b_instr[off];
-	i->i_opcode = opcode;
-	i->i_oparg = oparg;
-	i->i_hasarg = 1;
-	compiler_set_lineno(c, off);
-	return 1;
+    struct instr *i;
+    int off;
+    off = compiler_next_instr(c, c->u->u_curblock);
+    if (off < 0)
+        return 0;
+    i = &c->u->u_curblock->b_instr[off];
+    i->i_opcode = opcode;
+    i->i_oparg = oparg;
+    i->i_hasarg = 1;
+    compiler_set_lineno(c, off);
+    return 1;
 }
 
 static int
 compiler_addop_j(struct compiler *c, int opcode, basicblock *b, int absolute)
 {
-	struct instr *i;
-	int off;
-
-	assert(b != NULL);
-	off = compiler_next_instr(c, c->u->u_curblock);
-	if (off < 0)
-		return 0;
-	i = &c->u->u_curblock->b_instr[off];
-	i->i_opcode = opcode;
-	i->i_target = b;
-	i->i_hasarg = 1;
-	if (absolute)
-		i->i_jabs = 1;
-	else
-		i->i_jrel = 1;
-	compiler_set_lineno(c, off);
-	return 1;
-}
-
-/* The distinction between NEW_BLOCK and NEXT_BLOCK is subtle.	(I'd
-   like to find better names.)	NEW_BLOCK() creates a new block and sets
+    struct instr *i;
+    int off;
+
+    assert(b != NULL);
+    off = compiler_next_instr(c, c->u->u_curblock);
+    if (off < 0)
+        return 0;
+    i = &c->u->u_curblock->b_instr[off];
+    i->i_opcode = opcode;
+    i->i_target = b;
+    i->i_hasarg = 1;
+    if (absolute)
+        i->i_jabs = 1;
+    else
+        i->i_jrel = 1;
+    compiler_set_lineno(c, off);
+    return 1;
+}
+
+/* The distinction between NEW_BLOCK and NEXT_BLOCK is subtle.  (I'd
+   like to find better names.)  NEW_BLOCK() creates a new block and sets
    it as the current block.  NEXT_BLOCK() also creates an implicit jump
    from the current block to the new block.
 */
@@ -1067,50 +1067,50 @@ compiler_addop_j(struct compiler *c, int opcode, basicblock *b, int absolute)
 
 
 #define NEW_BLOCK(C) { \
-	if (compiler_use_new_block((C)) == NULL) \
-		return 0; \
+    if (compiler_use_new_block((C)) == NULL) \
+        return 0; \
 }
 
 #define NEXT_BLOCK(C) { \
-	if (compiler_next_block((C)) == NULL) \
-		return 0; \
+    if (compiler_next_block((C)) == NULL) \
+        return 0; \
 }
 
 #define ADDOP(C, OP) { \
-	if (!compiler_addop((C), (OP))) \
-		return 0; \
+    if (!compiler_addop((C), (OP))) \
+        return 0; \
 }
 
 #define ADDOP_IN_SCOPE(C, OP) { \
-	if (!compiler_addop((C), (OP))) { \
-		compiler_exit_scope(c); \
-		return 0; \
-	} \
+    if (!compiler_addop((C), (OP))) { \
+        compiler_exit_scope(c); \
+        return 0; \
+    } \
 }
 
 #define ADDOP_O(C, OP, O, TYPE) { \
-	if (!compiler_addop_o((C), (OP), (C)->u->u_ ## TYPE, (O))) \
-		return 0; \
+    if (!compiler_addop_o((C), (OP), (C)->u->u_ ## TYPE, (O))) \
+        return 0; \
 }
 
 #define ADDOP_NAME(C, OP, O, TYPE) { \
-	if (!compiler_addop_name((C), (OP), (C)->u->u_ ## TYPE, (O))) \
-		return 0; \
+    if (!compiler_addop_name((C), (OP), (C)->u->u_ ## TYPE, (O))) \
+        return 0; \
 }
 
 #define ADDOP_I(C, OP, O) { \
-	if (!compiler_addop_i((C), (OP), (O))) \
-		return 0; \
+    if (!compiler_addop_i((C), (OP), (O))) \
+        return 0; \
 }
 
 #define ADDOP_JABS(C, OP, O) { \
-	if (!compiler_addop_j((C), (OP), (O), 1)) \
-		return 0; \
+    if (!compiler_addop_j((C), (OP), (O), 1)) \
+        return 0; \
 }
 
 #define ADDOP_JREL(C, OP, O) { \
-	if (!compiler_addop_j((C), (OP), (O), 0)) \
-		return 0; \
+    if (!compiler_addop_j((C), (OP), (O), 0)) \
+        return 0; \
 }
 
 /* VISIT and VISIT_SEQ takes an ASDL type as their second argument.  They use
@@ -1118,49 +1118,49 @@ compiler_addop_j(struct compiler *c, int opcode, basicblock *b, int absolute)
 */
 
 #define VISIT(C, TYPE, V) {\
-	if (!compiler_visit_ ## TYPE((C), (V))) \
-		return 0; \
+    if (!compiler_visit_ ## TYPE((C), (V))) \
+        return 0; \
 }
 
 #define VISIT_IN_SCOPE(C, TYPE, V) {\
-	if (!compiler_visit_ ## TYPE((C), (V))) { \
-		compiler_exit_scope(c); \
-		return 0; \
-	} \
+    if (!compiler_visit_ ## TYPE((C), (V))) { \
+        compiler_exit_scope(c); \
+        return 0; \
+    } \
 }
 
 #define VISIT_SLICE(C, V, CTX) {\
-	if (!compiler_visit_slice((C), (V), (CTX))) \
-		return 0; \
+    if (!compiler_visit_slice((C), (V), (CTX))) \
+        return 0; \
 }
 
 #define VISIT_SEQ(C, TYPE, SEQ) { \
-	int _i; \
-	asdl_seq *seq = (SEQ); /* avoid variable capture */ \
-	for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \
-		TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \
-		if (!compiler_visit_ ## TYPE((C), elt)) \
-			return 0; \
-	} \
+    int _i; \
+    asdl_seq *seq = (SEQ); /* avoid variable capture */ \
+    for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \
+        TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \
+        if (!compiler_visit_ ## TYPE((C), elt)) \
+            return 0; \
+    } \
 }
 
 #define VISIT_SEQ_IN_SCOPE(C, TYPE, SEQ) { \
-	int _i; \
-	asdl_seq *seq = (SEQ); /* avoid variable capture */ \
-	for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \
-		TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \
-		if (!compiler_visit_ ## TYPE((C), elt)) { \
-			compiler_exit_scope(c); \
-			return 0; \
-		} \
-	} \
+    int _i; \
+    asdl_seq *seq = (SEQ); /* avoid variable capture */ \
+    for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \
+        TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \
+        if (!compiler_visit_ ## TYPE((C), elt)) { \
+            compiler_exit_scope(c); \
+            return 0; \
+        } \
+    } \
 }
 
 static int
 compiler_isdocstring(stmt_ty s)
 {
     if (s->kind != Expr_kind)
-	return 0;
+    return 0;
     return s->v.Expr.value->kind == Str_kind;
 }
 
@@ -1169,67 +1169,67 @@ compiler_isdocstring(stmt_ty s)
 static int
 compiler_body(struct compiler *c, asdl_seq *stmts)
 {
-	int i = 0;
-	stmt_ty st;
-
-	if (!asdl_seq_LEN(stmts))
-		return 1;
-	st = (stmt_ty)asdl_seq_GET(stmts, 0);
-	if (compiler_isdocstring(st) && Py_OptimizeFlag < 2) {
-		/* don't generate docstrings if -OO */
-		i = 1;
-		VISIT(c, expr, st->v.Expr.value);
-		if (!compiler_nameop(c, __doc__, Store))
-			return 0;
-	}
-	for (; i < asdl_seq_LEN(stmts); i++)
-	    VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i));
-	return 1;
+    int i = 0;
+    stmt_ty st;
+
+    if (!asdl_seq_LEN(stmts))
+        return 1;
+    st = (stmt_ty)asdl_seq_GET(stmts, 0);
+    if (compiler_isdocstring(st) && Py_OptimizeFlag < 2) {
+        /* don't generate docstrings if -OO */
+        i = 1;
+        VISIT(c, expr, st->v.Expr.value);
+        if (!compiler_nameop(c, __doc__, Store))
+            return 0;
+    }
+    for (; i < asdl_seq_LEN(stmts); i++)
+        VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i));
+    return 1;
 }
 
 static PyCodeObject *
 compiler_mod(struct compiler *c, mod_ty mod)
 {
-	PyCodeObject *co;
-	int addNone = 1;
-	static PyObject *module;
-	if (!module) {
-		module = PyString_InternFromString("<module>");
-		if (!module)
-			return NULL;
-	}
-	/* Use 0 for firstlineno initially, will fixup in assemble(). */
-	if (!compiler_enter_scope(c, module, mod, 0))
-		return NULL;
-	switch (mod->kind) {
-	case Module_kind: 
-		if (!compiler_body(c, mod->v.Module.body)) {
-			compiler_exit_scope(c);
-			return 0;
-		}
-		break;
-	case Interactive_kind:
-		c->c_interactive = 1;
-		VISIT_SEQ_IN_SCOPE(c, stmt, 
-					mod->v.Interactive.body);
-		break;
-	case Expression_kind:
-		VISIT_IN_SCOPE(c, expr, mod->v.Expression.body);
-		addNone = 0;
-		break;
-	case Suite_kind:
-		PyErr_SetString(PyExc_SystemError,
-				"suite should not be possible");
-		return 0;
-	default:
-		PyErr_Format(PyExc_SystemError,
-			     "module kind %d should not be possible",
-			     mod->kind);
-		return 0;
-	}
-	co = assemble(c, addNone);
-	compiler_exit_scope(c);
-	return co;
+    PyCodeObject *co;
+    int addNone = 1;
+    static PyObject *module;
+    if (!module) {
+        module = PyString_InternFromString("<module>");
+        if (!module)
+            return NULL;
+    }
+    /* Use 0 for firstlineno initially, will fixup in assemble(). */
+    if (!compiler_enter_scope(c, module, mod, 0))
+        return NULL;
+    switch (mod->kind) {
+    case Module_kind:
+        if (!compiler_body(c, mod->v.Module.body)) {
+            compiler_exit_scope(c);
+            return 0;
+        }
+        break;
+    case Interactive_kind:
+        c->c_interactive = 1;
+        VISIT_SEQ_IN_SCOPE(c, stmt,
+                                mod->v.Interactive.body);
+        break;
+    case Expression_kind:
+        VISIT_IN_SCOPE(c, expr, mod->v.Expression.body);
+        addNone = 0;
+        break;
+    case Suite_kind:
+        PyErr_SetString(PyExc_SystemError,
+                        "suite should not be possible");
+        return 0;
+    default:
+        PyErr_Format(PyExc_SystemError,
+                     "module kind %d should not be possible",
+                     mod->kind);
+        return 0;
+    }
+    co = assemble(c, addNone);
+    compiler_exit_scope(c);
+    return co;
 }
 
 /* The test for LOCAL must come before the test for FREE in order to
@@ -1240,24 +1240,24 @@ compiler_mod(struct compiler *c, mod_ty mod)
 static int
 get_ref_type(struct compiler *c, PyObject *name)
 {
-	int scope = PyST_GetScope(c->u->u_ste, name);
-	if (scope == 0) {
-	    char buf[350];
-	    PyOS_snprintf(buf, sizeof(buf),
-			  "unknown scope for %.100s in %.100s(%s) in %s\n"
-			  "symbols: %s\nlocals: %s\nglobals: %s",
-			  PyString_AS_STRING(name), 
-			  PyString_AS_STRING(c->u->u_name), 
-			  PyObject_REPR(c->u->u_ste->ste_id),
-			  c->c_filename,
-			  PyObject_REPR(c->u->u_ste->ste_symbols),
-			  PyObject_REPR(c->u->u_varnames),
-			  PyObject_REPR(c->u->u_names)
-		);
-	    Py_FatalError(buf);
-	}
+    int scope = PyST_GetScope(c->u->u_ste, name);
+    if (scope == 0) {
+        char buf[350];
+        PyOS_snprintf(buf, sizeof(buf),
+                      "unknown scope for %.100s in %.100s(%s) in %s\n"
+                      "symbols: %s\nlocals: %s\nglobals: %s",
+                      PyString_AS_STRING(name),
+                      PyString_AS_STRING(c->u->u_name),
+                      PyObject_REPR(c->u->u_ste->ste_id),
+                      c->c_filename,
+                      PyObject_REPR(c->u->u_ste->ste_symbols),
+                      PyObject_REPR(c->u->u_varnames),
+                      PyObject_REPR(c->u->u_names)
+        );
+        Py_FatalError(buf);
+    }
 
-	return scope;
+    return scope;
 }
 
 static int
@@ -1266,505 +1266,505 @@ compiler_lookup_arg(PyObject *dict, PyObject *name)
     PyObject *k, *v;
     k = PyTuple_Pack(2, name, name->ob_type);
     if (k == NULL)
-	return -1;
+    return -1;
     v = PyDict_GetItem(dict, k);
     Py_DECREF(k);
     if (v == NULL)
-	return -1;
+    return -1;
     return PyInt_AS_LONG(v);
 }
 
 static int
 compiler_make_closure(struct compiler *c, PyCodeObject *co, int args)
 {
-	int i, free = PyCode_GetNumFree(co);
-	if (free == 0) {
-	    ADDOP_O(c, LOAD_CONST, (PyObject*)co, consts);
-	    ADDOP_I(c, MAKE_FUNCTION, args);
-	    return 1;
-	}
-	for (i = 0; i < free; ++i) {
-		/* Bypass com_addop_varname because it will generate
-		   LOAD_DEREF but LOAD_CLOSURE is needed. 
-		*/
-		PyObject *name = PyTuple_GET_ITEM(co->co_freevars, i);
-		int arg, reftype;
-
-		/* Special case: If a class contains a method with a
-		   free variable that has the same name as a method,
-		   the name will be considered free *and* local in the
-		   class.  It should be handled by the closure, as
-		   well as by the normal name loookup logic.
-		*/
-		reftype = get_ref_type(c, name);
-		if (reftype == CELL)
-			arg = compiler_lookup_arg(c->u->u_cellvars, name);
-		else /* (reftype == FREE) */
-			arg = compiler_lookup_arg(c->u->u_freevars, name);
-		if (arg == -1) {
-			printf("lookup %s in %s %d %d\n"
-				"freevars of %s: %s\n",
-				PyObject_REPR(name), 
-				PyString_AS_STRING(c->u->u_name), 
-				reftype, arg,
-				PyString_AS_STRING(co->co_name),
-				PyObject_REPR(co->co_freevars));
-			Py_FatalError("compiler_make_closure()");
-		}
-		ADDOP_I(c, LOAD_CLOSURE, arg);
-	}
-	ADDOP_I(c, BUILD_TUPLE, free);
-	ADDOP_O(c, LOAD_CONST, (PyObject*)co, consts);
-	ADDOP_I(c, MAKE_CLOSURE, args);
-	return 1;
+    int i, free = PyCode_GetNumFree(co);
+    if (free == 0) {
+        ADDOP_O(c, LOAD_CONST, (PyObject*)co, consts);
+        ADDOP_I(c, MAKE_FUNCTION, args);
+        return 1;
+    }
+    for (i = 0; i < free; ++i) {
+        /* Bypass com_addop_varname because it will generate
+           LOAD_DEREF but LOAD_CLOSURE is needed.
+        */
+        PyObject *name = PyTuple_GET_ITEM(co->co_freevars, i);
+        int arg, reftype;
+
+        /* Special case: If a class contains a method with a
+           free variable that has the same name as a method,
+           the name will be considered free *and* local in the
+           class.  It should be handled by the closure, as
+           well as by the normal name loookup logic.
+        */
+        reftype = get_ref_type(c, name);
+        if (reftype == CELL)
+            arg = compiler_lookup_arg(c->u->u_cellvars, name);
+        else /* (reftype == FREE) */
+            arg = compiler_lookup_arg(c->u->u_freevars, name);
+        if (arg == -1) {
+            printf("lookup %s in %s %d %d\n"
+                "freevars of %s: %s\n",
+                PyObject_REPR(name),
+                PyString_AS_STRING(c->u->u_name),
+                reftype, arg,
+                PyString_AS_STRING(co->co_name),
+                PyObject_REPR(co->co_freevars));
+            Py_FatalError("compiler_make_closure()");
+        }
+        ADDOP_I(c, LOAD_CLOSURE, arg);
+    }
+    ADDOP_I(c, BUILD_TUPLE, free);
+    ADDOP_O(c, LOAD_CONST, (PyObject*)co, consts);
+    ADDOP_I(c, MAKE_CLOSURE, args);
+    return 1;
 }
 
 static int
 compiler_decorators(struct compiler *c, asdl_seq* decos)
 {
-	int i;
+    int i;
 
-	if (!decos)
-		return 1;
+    if (!decos)
+        return 1;
 
-	for (i = 0; i < asdl_seq_LEN(decos); i++) {
-		VISIT(c, expr, (expr_ty)asdl_seq_GET(decos, i));
-	}
-	return 1;
+    for (i = 0; i < asdl_seq_LEN(decos); i++) {
+        VISIT(c, expr, (expr_ty)asdl_seq_GET(decos, i));
+    }
+    return 1;
 }
 
 static int
 compiler_arguments(struct compiler *c, arguments_ty args)
 {
-	int i;
-	int n = asdl_seq_LEN(args->args);
-	/* Correctly handle nested argument lists */
-	for (i = 0; i < n; i++) {
-		expr_ty arg = (expr_ty)asdl_seq_GET(args->args, i);
-		if (arg->kind == Tuple_kind) {
-			PyObject *id = PyString_FromFormat(".%d", i);
-			if (id == NULL) {
-				return 0;
-			}
-			if (!compiler_nameop(c, id, Load)) {
-				Py_DECREF(id);
-				return 0;
-			}
-			Py_DECREF(id);
-			VISIT(c, expr, arg);
-		}
-	}
-	return 1;
+    int i;
+    int n = asdl_seq_LEN(args->args);
+    /* Correctly handle nested argument lists */
+    for (i = 0; i < n; i++) {
+        expr_ty arg = (expr_ty)asdl_seq_GET(args->args, i);
+        if (arg->kind == Tuple_kind) {
+            PyObject *id = PyString_FromFormat(".%d", i);
+            if (id == NULL) {
+                return 0;
+            }
+            if (!compiler_nameop(c, id, Load)) {
+                Py_DECREF(id);
+                return 0;
+            }
+            Py_DECREF(id);
+            VISIT(c, expr, arg);
+        }
+    }
+    return 1;
 }
 
 static int
 compiler_function(struct compiler *c, stmt_ty s)
 {
-	PyCodeObject *co;
-	PyObject *first_const = Py_None;
-	arguments_ty args = s->v.FunctionDef.args;
-	asdl_seq* decos = s->v.FunctionDef.decorator_list;
-	stmt_ty st;
-	int i, n, docstring;
-
-	assert(s->kind == FunctionDef_kind);
-
-	if (!compiler_decorators(c, decos))
-		return 0;
-	if (args->defaults)
-		VISIT_SEQ(c, expr, args->defaults);
-	if (!compiler_enter_scope(c, s->v.FunctionDef.name, (void *)s,
-				  s->lineno))
-		return 0;
-
-	st = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, 0);
-	docstring = compiler_isdocstring(st);
-	if (docstring && Py_OptimizeFlag < 2)
-	    first_const = st->v.Expr.value->v.Str.s;
-	if (compiler_add_o(c, c->u->u_consts, first_const) < 0)	 {
-	    compiler_exit_scope(c);
-	    return 0;
-	}
-
-	/* unpack nested arguments */
-	compiler_arguments(c, args);
-
-	c->u->u_argcount = asdl_seq_LEN(args->args);
-	n = asdl_seq_LEN(s->v.FunctionDef.body);
-	/* if there was a docstring, we need to skip the first statement */
-	for (i = docstring; i < n; i++) {
-		st = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, i);
-		VISIT_IN_SCOPE(c, stmt, st);
-	}
-	co = assemble(c, 1);
-	compiler_exit_scope(c);
-	if (co == NULL)
-		return 0;
-
-	compiler_make_closure(c, co, asdl_seq_LEN(args->defaults));
-	Py_DECREF(co);
-
-	for (i = 0; i < asdl_seq_LEN(decos); i++) {
-		ADDOP_I(c, CALL_FUNCTION, 1);
-	}
-
-	return compiler_nameop(c, s->v.FunctionDef.name, Store);
+    PyCodeObject *co;
+    PyObject *first_const = Py_None;
+    arguments_ty args = s->v.FunctionDef.args;
+    asdl_seq* decos = s->v.FunctionDef.decorator_list;
+    stmt_ty st;
+    int i, n, docstring;
+
+    assert(s->kind == FunctionDef_kind);
+
+    if (!compiler_decorators(c, decos))
+        return 0;
+    if (args->defaults)
+        VISIT_SEQ(c, expr, args->defaults);
+    if (!compiler_enter_scope(c, s->v.FunctionDef.name, (void *)s,
+                              s->lineno))
+        return 0;
+
+    st = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, 0);
+    docstring = compiler_isdocstring(st);
+    if (docstring && Py_OptimizeFlag < 2)
+        first_const = st->v.Expr.value->v.Str.s;
+    if (compiler_add_o(c, c->u->u_consts, first_const) < 0)      {
+        compiler_exit_scope(c);
+        return 0;
+    }
+
+    /* unpack nested arguments */
+    compiler_arguments(c, args);
+
+    c->u->u_argcount = asdl_seq_LEN(args->args);
+    n = asdl_seq_LEN(s->v.FunctionDef.body);
+    /* if there was a docstring, we need to skip the first statement */
+    for (i = docstring; i < n; i++) {
+        st = (stmt_ty)asdl_seq_GET(s->v.FunctionDef.body, i);
+        VISIT_IN_SCOPE(c, stmt, st);
+    }
+    co = assemble(c, 1);
+    compiler_exit_scope(c);
+    if (co == NULL)
+        return 0;
+
+    compiler_make_closure(c, co, asdl_seq_LEN(args->defaults));
+    Py_DECREF(co);
+
+    for (i = 0; i < asdl_seq_LEN(decos); i++) {
+        ADDOP_I(c, CALL_FUNCTION, 1);
+    }
+
+    return compiler_nameop(c, s->v.FunctionDef.name, Store);
 }
 
 static int
 compiler_class(struct compiler *c, stmt_ty s)
 {
-	int n, i;
-	PyCodeObject *co;
-	PyObject *str;
-	asdl_seq* decos = s->v.ClassDef.decorator_list;
-	
-	if (!compiler_decorators(c, decos))
-		return 0;
-
-	/* push class name on stack, needed by BUILD_CLASS */
-	ADDOP_O(c, LOAD_CONST, s->v.ClassDef.name, consts);
-	/* push the tuple of base classes on the stack */
-	n = asdl_seq_LEN(s->v.ClassDef.bases);
-	if (n > 0)
-		VISIT_SEQ(c, expr, s->v.ClassDef.bases);
-	ADDOP_I(c, BUILD_TUPLE, n);
-	if (!compiler_enter_scope(c, s->v.ClassDef.name, (void *)s,
-				  s->lineno))
-		return 0;
-	Py_XDECREF(c->u->u_private);
-	c->u->u_private = s->v.ClassDef.name;
-	Py_INCREF(c->u->u_private);
-	str = PyString_InternFromString("__name__");
-	if (!str || !compiler_nameop(c, str, Load)) {
-		Py_XDECREF(str);
-		compiler_exit_scope(c);
-		return 0;
-	}
-	
-	Py_DECREF(str);
-	str = PyString_InternFromString("__module__");
-	if (!str || !compiler_nameop(c, str, Store)) {
-		Py_XDECREF(str);
-		compiler_exit_scope(c);
-		return 0;
-	}
-	Py_DECREF(str);
-
-	if (!compiler_body(c, s->v.ClassDef.body)) {
-		compiler_exit_scope(c);
-		return 0;
-	}
-
-	ADDOP_IN_SCOPE(c, LOAD_LOCALS);
-	ADDOP_IN_SCOPE(c, RETURN_VALUE);
-	co = assemble(c, 1);
-	compiler_exit_scope(c);
-	if (co == NULL)
-		return 0;
-
-	compiler_make_closure(c, co, 0);
-	Py_DECREF(co);
-
-	ADDOP_I(c, CALL_FUNCTION, 0);
-	ADDOP(c, BUILD_CLASS);
-	/* apply decorators */
-	for (i = 0; i < asdl_seq_LEN(decos); i++) {
-		ADDOP_I(c, CALL_FUNCTION, 1);
-	}
-	if (!compiler_nameop(c, s->v.ClassDef.name, Store))
-		return 0;
-	return 1;
+    int n, i;
+    PyCodeObject *co;
+    PyObject *str;
+    asdl_seq* decos = s->v.ClassDef.decorator_list;
+
+    if (!compiler_decorators(c, decos))
+        return 0;
+
+    /* push class name on stack, needed by BUILD_CLASS */
+    ADDOP_O(c, LOAD_CONST, s->v.ClassDef.name, consts);
+    /* push the tuple of base classes on the stack */
+    n = asdl_seq_LEN(s->v.ClassDef.bases);
+    if (n > 0)
+        VISIT_SEQ(c, expr, s->v.ClassDef.bases);
+    ADDOP_I(c, BUILD_TUPLE, n);
+    if (!compiler_enter_scope(c, s->v.ClassDef.name, (void *)s,
+                              s->lineno))
+        return 0;
+    Py_XDECREF(c->u->u_private);
+    c->u->u_private = s->v.ClassDef.name;
+    Py_INCREF(c->u->u_private);
+    str = PyString_InternFromString("__name__");
+    if (!str || !compiler_nameop(c, str, Load)) {
+        Py_XDECREF(str);
+        compiler_exit_scope(c);
+        return 0;
+    }
+
+    Py_DECREF(str);
+    str = PyString_InternFromString("__module__");
+    if (!str || !compiler_nameop(c, str, Store)) {
+        Py_XDECREF(str);
+        compiler_exit_scope(c);
+        return 0;
+    }
+    Py_DECREF(str);
+
+    if (!compiler_body(c, s->v.ClassDef.body)) {
+        compiler_exit_scope(c);
+        return 0;
+    }
+
+    ADDOP_IN_SCOPE(c, LOAD_LOCALS);
+    ADDOP_IN_SCOPE(c, RETURN_VALUE);
+    co = assemble(c, 1);
+    compiler_exit_scope(c);
+    if (co == NULL)
+        return 0;
+
+    compiler_make_closure(c, co, 0);
+    Py_DECREF(co);
+
+    ADDOP_I(c, CALL_FUNCTION, 0);
+    ADDOP(c, BUILD_CLASS);
+    /* apply decorators */
+    for (i = 0; i < asdl_seq_LEN(decos); i++) {
+        ADDOP_I(c, CALL_FUNCTION, 1);
+    }
+    if (!compiler_nameop(c, s->v.ClassDef.name, Store))
+        return 0;
+    return 1;
 }
 
 static int
 compiler_ifexp(struct compiler *c, expr_ty e)
 {
-	basicblock *end, *next;
-	
-	assert(e->kind == IfExp_kind);
-	end = compiler_new_block(c);
-	if (end == NULL)
-		return 0;
-	next = compiler_new_block(c);
-	if (next == NULL)
-		return 0;
-	VISIT(c, expr, e->v.IfExp.test);
-	ADDOP_JABS(c, POP_JUMP_IF_FALSE, next);
-	VISIT(c, expr, e->v.IfExp.body);
-	ADDOP_JREL(c, JUMP_FORWARD, end);
-	compiler_use_next_block(c, next);
-	VISIT(c, expr, e->v.IfExp.orelse);
-	compiler_use_next_block(c, end);
-	return 1;
+    basicblock *end, *next;
+
+    assert(e->kind == IfExp_kind);
+    end = compiler_new_block(c);
+    if (end == NULL)
+        return 0;
+    next = compiler_new_block(c);
+    if (next == NULL)
+        return 0;
+    VISIT(c, expr, e->v.IfExp.test);
+    ADDOP_JABS(c, POP_JUMP_IF_FALSE, next);
+    VISIT(c, expr, e->v.IfExp.body);
+    ADDOP_JREL(c, JUMP_FORWARD, end);
+    compiler_use_next_block(c, next);
+    VISIT(c, expr, e->v.IfExp.orelse);
+    compiler_use_next_block(c, end);
+    return 1;
 }
 
 static int
 compiler_lambda(struct compiler *c, expr_ty e)
 {
-	PyCodeObject *co;
-	static identifier name;
-	arguments_ty args = e->v.Lambda.args;
-	assert(e->kind == Lambda_kind);
-
-	if (!name) {
-		name = PyString_InternFromString("<lambda>");
-		if (!name)
-			return 0;
-	}
-
-	if (args->defaults)
-		VISIT_SEQ(c, expr, args->defaults);
-	if (!compiler_enter_scope(c, name, (void *)e, e->lineno))
-		return 0;
-
-	/* unpack nested arguments */
-	compiler_arguments(c, args);
-
-	/* Make None the first constant, so the lambda can't have a
-	   docstring. */
-	if (compiler_add_o(c, c->u->u_consts, Py_None) < 0)
-		return 0;
-	
-	c->u->u_argcount = asdl_seq_LEN(args->args);
-	VISIT_IN_SCOPE(c, expr, e->v.Lambda.body);
-	if (c->u->u_ste->ste_generator) {
-		ADDOP_IN_SCOPE(c, POP_TOP);
-	}
-	else {
-		ADDOP_IN_SCOPE(c, RETURN_VALUE);
-	}
-	co = assemble(c, 1);
-	compiler_exit_scope(c);
-	if (co == NULL)
-		return 0;
-
-	compiler_make_closure(c, co, asdl_seq_LEN(args->defaults));
-	Py_DECREF(co);
-
-	return 1;
+    PyCodeObject *co;
+    static identifier name;
+    arguments_ty args = e->v.Lambda.args;
+    assert(e->kind == Lambda_kind);
+
+    if (!name) {
+        name = PyString_InternFromString("<lambda>");
+        if (!name)
+            return 0;
+    }
+
+    if (args->defaults)
+        VISIT_SEQ(c, expr, args->defaults);
+    if (!compiler_enter_scope(c, name, (void *)e, e->lineno))
+        return 0;
+
+    /* unpack nested arguments */
+    compiler_arguments(c, args);
+
+    /* Make None the first constant, so the lambda can't have a
+       docstring. */
+    if (compiler_add_o(c, c->u->u_consts, Py_None) < 0)
+        return 0;
+
+    c->u->u_argcount = asdl_seq_LEN(args->args);
+    VISIT_IN_SCOPE(c, expr, e->v.Lambda.body);
+    if (c->u->u_ste->ste_generator) {
+        ADDOP_IN_SCOPE(c, POP_TOP);
+    }
+    else {
+        ADDOP_IN_SCOPE(c, RETURN_VALUE);
+    }
+    co = assemble(c, 1);
+    compiler_exit_scope(c);
+    if (co == NULL)
+        return 0;
+
+    compiler_make_closure(c, co, asdl_seq_LEN(args->defaults));
+    Py_DECREF(co);
+
+    return 1;
 }
 
 static int
 compiler_print(struct compiler *c, stmt_ty s)
 {
-	int i, n;
-	bool dest;
-
-	assert(s->kind == Print_kind);
-	n = asdl_seq_LEN(s->v.Print.values);
-	dest = false;
-	if (s->v.Print.dest) {
-		VISIT(c, expr, s->v.Print.dest);
-		dest = true;
-	}
-	for (i = 0; i < n; i++) {
-		expr_ty e = (expr_ty)asdl_seq_GET(s->v.Print.values, i);
-		if (dest) {
-			ADDOP(c, DUP_TOP);
-			VISIT(c, expr, e);
-			ADDOP(c, ROT_TWO);
-			ADDOP(c, PRINT_ITEM_TO);
-		}
-		else {
-			VISIT(c, expr, e);
-			ADDOP(c, PRINT_ITEM);
-		}
-	}
-	if (s->v.Print.nl) {
-		if (dest)
-			ADDOP(c, PRINT_NEWLINE_TO)
-		else
-			ADDOP(c, PRINT_NEWLINE)
-	}
-	else if (dest)
-		ADDOP(c, POP_TOP);
-	return 1;
+    int i, n;
+    bool dest;
+
+    assert(s->kind == Print_kind);
+    n = asdl_seq_LEN(s->v.Print.values);
+    dest = false;
+    if (s->v.Print.dest) {
+        VISIT(c, expr, s->v.Print.dest);
+        dest = true;
+    }
+    for (i = 0; i < n; i++) {
+        expr_ty e = (expr_ty)asdl_seq_GET(s->v.Print.values, i);
+        if (dest) {
+            ADDOP(c, DUP_TOP);
+            VISIT(c, expr, e);
+            ADDOP(c, ROT_TWO);
+            ADDOP(c, PRINT_ITEM_TO);
+        }
+        else {
+            VISIT(c, expr, e);
+            ADDOP(c, PRINT_ITEM);
+        }
+    }
+    if (s->v.Print.nl) {
+        if (dest)
+            ADDOP(c, PRINT_NEWLINE_TO)
+        else
+            ADDOP(c, PRINT_NEWLINE)
+    }
+    else if (dest)
+        ADDOP(c, POP_TOP);
+    return 1;
 }
 
 static int
 compiler_if(struct compiler *c, stmt_ty s)
 {
-	basicblock *end, *next;
-	int constant;
-	assert(s->kind == If_kind);
-	end = compiler_new_block(c);
-	if (end == NULL)
-		return 0;
-	
-	constant = expr_constant(s->v.If.test);
-	/* constant = 0: "if 0"
-	 * constant = 1: "if 1", "if 2", ...
-	 * constant = -1: rest */
-	if (constant == 0) {
-		if (s->v.If.orelse)
-			VISIT_SEQ(c, stmt, s->v.If.orelse);
-	} else if (constant == 1) {
-		VISIT_SEQ(c, stmt, s->v.If.body);
-	} else {
-		if (s->v.If.orelse) {
-			next = compiler_new_block(c);
-			if (next == NULL)
-			    return 0;
-		}
-		else
-			next = end;
-		VISIT(c, expr, s->v.If.test);
-		ADDOP_JABS(c, POP_JUMP_IF_FALSE, next);
-		VISIT_SEQ(c, stmt, s->v.If.body);
-		ADDOP_JREL(c, JUMP_FORWARD, end);
-		if (s->v.If.orelse) {
-			compiler_use_next_block(c, next);
-			VISIT_SEQ(c, stmt, s->v.If.orelse);
-		}
-	}
-	compiler_use_next_block(c, end);
-	return 1;
+    basicblock *end, *next;
+    int constant;
+    assert(s->kind == If_kind);
+    end = compiler_new_block(c);
+    if (end == NULL)
+        return 0;
+
+    constant = expr_constant(s->v.If.test);
+    /* constant = 0: "if 0"
+     * constant = 1: "if 1", "if 2", ...
+     * constant = -1: rest */
+    if (constant == 0) {
+        if (s->v.If.orelse)
+            VISIT_SEQ(c, stmt, s->v.If.orelse);
+    } else if (constant == 1) {
+        VISIT_SEQ(c, stmt, s->v.If.body);
+    } else {
+        if (s->v.If.orelse) {
+            next = compiler_new_block(c);
+            if (next == NULL)
+                return 0;
+        }
+        else
+            next = end;
+        VISIT(c, expr, s->v.If.test);
+        ADDOP_JABS(c, POP_JUMP_IF_FALSE, next);
+        VISIT_SEQ(c, stmt, s->v.If.body);
+        ADDOP_JREL(c, JUMP_FORWARD, end);
+        if (s->v.If.orelse) {
+            compiler_use_next_block(c, next);
+            VISIT_SEQ(c, stmt, s->v.If.orelse);
+        }
+    }
+    compiler_use_next_block(c, end);
+    return 1;
 }
 
 static int
 compiler_for(struct compiler *c, stmt_ty s)
 {
-	basicblock *start, *cleanup, *end;
-
-	start = compiler_new_block(c);
-	cleanup = compiler_new_block(c);
-	end = compiler_new_block(c);
-	if (start == NULL || end == NULL || cleanup == NULL)
-		return 0;
-	ADDOP_JREL(c, SETUP_LOOP, end);
-	if (!compiler_push_fblock(c, LOOP, start))
-		return 0;
-	VISIT(c, expr, s->v.For.iter);
-	ADDOP(c, GET_ITER);
-	compiler_use_next_block(c, start);
-	ADDOP_JREL(c, FOR_ITER, cleanup);
-	VISIT(c, expr, s->v.For.target);
-	VISIT_SEQ(c, stmt, s->v.For.body);
-	ADDOP_JABS(c, JUMP_ABSOLUTE, start);
-	compiler_use_next_block(c, cleanup);
-	ADDOP(c, POP_BLOCK);
-	compiler_pop_fblock(c, LOOP, start);
-	VISIT_SEQ(c, stmt, s->v.For.orelse);
-	compiler_use_next_block(c, end);
-	return 1;
+    basicblock *start, *cleanup, *end;
+
+    start = compiler_new_block(c);
+    cleanup = compiler_new_block(c);
+    end = compiler_new_block(c);
+    if (start == NULL || end == NULL || cleanup == NULL)
+        return 0;
+    ADDOP_JREL(c, SETUP_LOOP, end);
+    if (!compiler_push_fblock(c, LOOP, start))
+        return 0;
+    VISIT(c, expr, s->v.For.iter);
+    ADDOP(c, GET_ITER);
+    compiler_use_next_block(c, start);
+    ADDOP_JREL(c, FOR_ITER, cleanup);
+    VISIT(c, expr, s->v.For.target);
+    VISIT_SEQ(c, stmt, s->v.For.body);
+    ADDOP_JABS(c, JUMP_ABSOLUTE, start);
+    compiler_use_next_block(c, cleanup);
+    ADDOP(c, POP_BLOCK);
+    compiler_pop_fblock(c, LOOP, start);
+    VISIT_SEQ(c, stmt, s->v.For.orelse);
+    compiler_use_next_block(c, end);
+    return 1;
 }
 
 static int
 compiler_while(struct compiler *c, stmt_ty s)
 {
-	basicblock *loop, *orelse, *end, *anchor = NULL;
-	int constant = expr_constant(s->v.While.test);
-
-	if (constant == 0) {
-		if (s->v.While.orelse)
-			VISIT_SEQ(c, stmt, s->v.While.orelse);
-		return 1;
-	}
-	loop = compiler_new_block(c);
-	end = compiler_new_block(c);
-	if (constant == -1) {
-		anchor = compiler_new_block(c);
-		if (anchor == NULL)
-			return 0;
-	}
-	if (loop == NULL || end == NULL)
-		return 0;
-	if (s->v.While.orelse) {
-		orelse = compiler_new_block(c);
-		if (orelse == NULL)
-			return 0;
-	}
-	else
-		orelse = NULL;
-
-	ADDOP_JREL(c, SETUP_LOOP, end);
-	compiler_use_next_block(c, loop);
-	if (!compiler_push_fblock(c, LOOP, loop))
-		return 0;
-	if (constant == -1) {
-		VISIT(c, expr, s->v.While.test);
-		ADDOP_JABS(c, POP_JUMP_IF_FALSE, anchor);
-	}
-	VISIT_SEQ(c, stmt, s->v.While.body);
-	ADDOP_JABS(c, JUMP_ABSOLUTE, loop);
-
-	/* XXX should the two POP instructions be in a separate block
-	   if there is no else clause ?
-	*/
-
-	if (constant == -1) {
-		compiler_use_next_block(c, anchor);
-		ADDOP(c, POP_BLOCK);
-	}
-	compiler_pop_fblock(c, LOOP, loop);
-	if (orelse != NULL) /* what if orelse is just pass? */
-		VISIT_SEQ(c, stmt, s->v.While.orelse);
-	compiler_use_next_block(c, end);
-
-	return 1;
+    basicblock *loop, *orelse, *end, *anchor = NULL;
+    int constant = expr_constant(s->v.While.test);
+
+    if (constant == 0) {
+        if (s->v.While.orelse)
+            VISIT_SEQ(c, stmt, s->v.While.orelse);
+        return 1;
+    }
+    loop = compiler_new_block(c);
+    end = compiler_new_block(c);
+    if (constant == -1) {
+        anchor = compiler_new_block(c);
+        if (anchor == NULL)
+            return 0;
+    }
+    if (loop == NULL || end == NULL)
+        return 0;
+    if (s->v.While.orelse) {
+        orelse = compiler_new_block(c);
+        if (orelse == NULL)
+            return 0;
+    }
+    else
+        orelse = NULL;
+
+    ADDOP_JREL(c, SETUP_LOOP, end);
+    compiler_use_next_block(c, loop);
+    if (!compiler_push_fblock(c, LOOP, loop))
+        return 0;
+    if (constant == -1) {
+        VISIT(c, expr, s->v.While.test);
+        ADDOP_JABS(c, POP_JUMP_IF_FALSE, anchor);
+    }
+    VISIT_SEQ(c, stmt, s->v.While.body);
+    ADDOP_JABS(c, JUMP_ABSOLUTE, loop);
+
+    /* XXX should the two POP instructions be in a separate block
+       if there is no else clause ?
+    */
+
+    if (constant == -1) {
+        compiler_use_next_block(c, anchor);
+        ADDOP(c, POP_BLOCK);
+    }
+    compiler_pop_fblock(c, LOOP, loop);
+    if (orelse != NULL) /* what if orelse is just pass? */
+        VISIT_SEQ(c, stmt, s->v.While.orelse);
+    compiler_use_next_block(c, end);
+
+    return 1;
 }
 
 static int
 compiler_continue(struct compiler *c)
 {
-	static const char LOOP_ERROR_MSG[] = "'continue' not properly in loop";
-	static const char IN_FINALLY_ERROR_MSG[] = 
-			"'continue' not supported inside 'finally' clause";
-	int i;
-
-	if (!c->u->u_nfblocks)
-		return compiler_error(c, LOOP_ERROR_MSG);
-	i = c->u->u_nfblocks - 1;
-	switch (c->u->u_fblock[i].fb_type) {
-	case LOOP:
-		ADDOP_JABS(c, JUMP_ABSOLUTE, c->u->u_fblock[i].fb_block);
-		break;
-	case EXCEPT:
-	case FINALLY_TRY:
-		while (--i >= 0 && c->u->u_fblock[i].fb_type != LOOP) {
-			/* Prevent continue anywhere under a finally
-			      even if hidden in a sub-try or except. */
-			if (c->u->u_fblock[i].fb_type == FINALLY_END)
-				return compiler_error(c, IN_FINALLY_ERROR_MSG);
-		}
-		if (i == -1)
-			return compiler_error(c, LOOP_ERROR_MSG);
-		ADDOP_JABS(c, CONTINUE_LOOP, c->u->u_fblock[i].fb_block);
-		break;
-	case FINALLY_END:
-		return compiler_error(c, IN_FINALLY_ERROR_MSG);
-	}
-
-	return 1;
+    static const char LOOP_ERROR_MSG[] = "'continue' not properly in loop";
+    static const char IN_FINALLY_ERROR_MSG[] =
+                    "'continue' not supported inside 'finally' clause";
+    int i;
+
+    if (!c->u->u_nfblocks)
+        return compiler_error(c, LOOP_ERROR_MSG);
+    i = c->u->u_nfblocks - 1;
+    switch (c->u->u_fblock[i].fb_type) {
+    case LOOP:
+        ADDOP_JABS(c, JUMP_ABSOLUTE, c->u->u_fblock[i].fb_block);
+        break;
+    case EXCEPT:
+    case FINALLY_TRY:
+        while (--i >= 0 && c->u->u_fblock[i].fb_type != LOOP) {
+            /* Prevent continue anywhere under a finally
+                  even if hidden in a sub-try or except. */
+            if (c->u->u_fblock[i].fb_type == FINALLY_END)
+                return compiler_error(c, IN_FINALLY_ERROR_MSG);
+        }
+        if (i == -1)
+            return compiler_error(c, LOOP_ERROR_MSG);
+        ADDOP_JABS(c, CONTINUE_LOOP, c->u->u_fblock[i].fb_block);
+        break;
+    case FINALLY_END:
+        return compiler_error(c, IN_FINALLY_ERROR_MSG);
+    }
+
+    return 1;
 }
 
 /* Code generated for "try: <body> finally: <finalbody>" is as follows:
-   
-		SETUP_FINALLY	L
-		<code for body>
-		POP_BLOCK
-		LOAD_CONST	<None>
-	L:	<code for finalbody>
-		END_FINALLY
-   
+
+        SETUP_FINALLY           L
+        <code for body>
+        POP_BLOCK
+        LOAD_CONST              <None>
+    L:          <code for finalbody>
+        END_FINALLY
+
    The special instructions use the block stack.  Each block
    stack entry contains the instruction that created it (here
    SETUP_FINALLY), the level of the value stack at the time the
    block stack entry was created, and a label (here L).
-   
+
    SETUP_FINALLY:
-	Pushes the current value stack level and the label
-	onto the block stack.
+    Pushes the current value stack level and the label
+    onto the block stack.
    POP_BLOCK:
-	Pops en entry from the block stack, and pops the value
-	stack until its level is the same as indicated on the
-	block stack.  (The label is ignored.)
+    Pops en entry from the block stack, and pops the value
+    stack until its level is the same as indicated on the
+    block stack.  (The label is ignored.)
    END_FINALLY:
-	Pops a variable number of entries from the *value* stack
-	and re-raises the exception they specify.  The number of
-	entries popped depends on the (pseudo) exception type.
-   
+    Pops a variable number of entries from the *value* stack
+    and re-raises the exception they specify.  The number of
+    entries popped depends on the (pseudo) exception type.
+
    The block stack is unwound when an exception is raised:
    when a SETUP_FINALLY entry is found, the exception is pushed
    onto the value stack (and the exception condition is cleared),
@@ -1775,29 +1775,29 @@ compiler_continue(struct compiler *c)
 static int
 compiler_try_finally(struct compiler *c, stmt_ty s)
 {
-	basicblock *body, *end;
-	body = compiler_new_block(c);
-	end = compiler_new_block(c);
-	if (body == NULL || end == NULL)
-		return 0;
-
-	ADDOP_JREL(c, SETUP_FINALLY, end);
-	compiler_use_next_block(c, body);
-	if (!compiler_push_fblock(c, FINALLY_TRY, body))
-		return 0;
-	VISIT_SEQ(c, stmt, s->v.TryFinally.body);
-	ADDOP(c, POP_BLOCK);
-	compiler_pop_fblock(c, FINALLY_TRY, body);
+    basicblock *body, *end;
+    body = compiler_new_block(c);
+    end = compiler_new_block(c);
+    if (body == NULL || end == NULL)
+        return 0;
+
+    ADDOP_JREL(c, SETUP_FINALLY, end);
+    compiler_use_next_block(c, body);
+    if (!compiler_push_fblock(c, FINALLY_TRY, body))
+        return 0;
+    VISIT_SEQ(c, stmt, s->v.TryFinally.body);
+    ADDOP(c, POP_BLOCK);
+    compiler_pop_fblock(c, FINALLY_TRY, body);
 
-	ADDOP_O(c, LOAD_CONST, Py_None, consts);
-	compiler_use_next_block(c, end);
-	if (!compiler_push_fblock(c, FINALLY_END, end))
-		return 0;
-	VISIT_SEQ(c, stmt, s->v.TryFinally.finalbody);
-	ADDOP(c, END_FINALLY);
-	compiler_pop_fblock(c, FINALLY_END, end);
+    ADDOP_O(c, LOAD_CONST, Py_None, consts);
+    compiler_use_next_block(c, end);
+    if (!compiler_push_fblock(c, FINALLY_END, end))
+        return 0;
+    VISIT_SEQ(c, stmt, s->v.TryFinally.finalbody);
+    ADDOP(c, END_FINALLY);
+    compiler_pop_fblock(c, FINALLY_END, end);
 
-	return 1;
+    return 1;
 }
 
 /*
@@ -1805,853 +1805,853 @@ compiler_try_finally(struct compiler *c, stmt_ty s)
    (The contents of the value stack is shown in [], with the top
    at the right; 'tb' is trace-back info, 'val' the exception's
    associated value, and 'exc' the exception.)
-   
-   Value stack		Label	Instruction	Argument
-   []				SETUP_EXCEPT	L1
-   []				<code for S>
-   []				POP_BLOCK
-   []				JUMP_FORWARD	L0
-   
-   [tb, val, exc]	L1:	DUP				)
-   [tb, val, exc, exc]		<evaluate E1>			)
-   [tb, val, exc, exc, E1]	COMPARE_OP	EXC_MATCH	) only if E1
-   [tb, val, exc, 1-or-0]	POP_JUMP_IF_FALSE	L2	)
-   [tb, val, exc]		POP
-   [tb, val]			<assign to V1>	(or POP if no V1)
-   [tb]				POP
-   []				<code for S1>
-				JUMP_FORWARD	L0
-   
-   [tb, val, exc]	L2:	DUP
+
+   Value stack          Label   Instruction     Argument
+   []                           SETUP_EXCEPT    L1
+   []                           <code for S>
+   []                           POP_BLOCK
+   []                           JUMP_FORWARD    L0
+
+   [tb, val, exc]       L1:     DUP                             )
+   [tb, val, exc, exc]          <evaluate E1>                   )
+   [tb, val, exc, exc, E1]      COMPARE_OP      EXC_MATCH       ) only if E1
+   [tb, val, exc, 1-or-0]       POP_JUMP_IF_FALSE       L2      )
+   [tb, val, exc]               POP
+   [tb, val]                    <assign to V1>  (or POP if no V1)
+   [tb]                         POP
+   []                           <code for S1>
+                                JUMP_FORWARD    L0
+
+   [tb, val, exc]       L2:     DUP
    .............................etc.......................
 
-   [tb, val, exc]	Ln+1:	END_FINALLY	# re-raise exception
-   
-   []			L0:	<next statement>
-   
+   [tb, val, exc]       Ln+1:   END_FINALLY     # re-raise exception
+
+   []                   L0:     <next statement>
+
    Of course, parts are not generated if Vi or Ei is not present.
 */
 static int
 compiler_try_except(struct compiler *c, stmt_ty s)
 {
-	basicblock *body, *orelse, *except, *end;
-	int i, n;
-
-	body = compiler_new_block(c);
-	except = compiler_new_block(c);
-	orelse = compiler_new_block(c);
-	end = compiler_new_block(c);
-	if (body == NULL || except == NULL || orelse == NULL || end == NULL)
-		return 0;
-	ADDOP_JREL(c, SETUP_EXCEPT, except);
-	compiler_use_next_block(c, body);
-	if (!compiler_push_fblock(c, EXCEPT, body))
-		return 0;
-	VISIT_SEQ(c, stmt, s->v.TryExcept.body);
-	ADDOP(c, POP_BLOCK);
-	compiler_pop_fblock(c, EXCEPT, body);
-	ADDOP_JREL(c, JUMP_FORWARD, orelse);
-	n = asdl_seq_LEN(s->v.TryExcept.handlers);
-	compiler_use_next_block(c, except);
-	for (i = 0; i < n; i++) {
-		excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET(
-						s->v.TryExcept.handlers, i);
-		if (!handler->v.ExceptHandler.type && i < n-1)
-		    return compiler_error(c, "default 'except:' must be last");
-		c->u->u_lineno_set = false;
-		c->u->u_lineno = handler->lineno;
-		except = compiler_new_block(c);
-		if (except == NULL)
-			return 0;
-		if (handler->v.ExceptHandler.type) {
-			ADDOP(c, DUP_TOP);
-			VISIT(c, expr, handler->v.ExceptHandler.type);
-			ADDOP_I(c, COMPARE_OP, PyCmp_EXC_MATCH);
-			ADDOP_JABS(c, POP_JUMP_IF_FALSE, except);
-		}
-		ADDOP(c, POP_TOP);
-		if (handler->v.ExceptHandler.name) {
-			VISIT(c, expr, handler->v.ExceptHandler.name);
-		}
-		else {
-			ADDOP(c, POP_TOP);
-		}
-		ADDOP(c, POP_TOP);
-		VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body);
-		ADDOP_JREL(c, JUMP_FORWARD, end);
-		compiler_use_next_block(c, except);
-	}
-	ADDOP(c, END_FINALLY);
-	compiler_use_next_block(c, orelse);
-	VISIT_SEQ(c, stmt, s->v.TryExcept.orelse);
-	compiler_use_next_block(c, end);
-	return 1;
+    basicblock *body, *orelse, *except, *end;
+    int i, n;
+
+    body = compiler_new_block(c);
+    except = compiler_new_block(c);
+    orelse = compiler_new_block(c);
+    end = compiler_new_block(c);
+    if (body == NULL || except == NULL || orelse == NULL || end == NULL)
+        return 0;
+    ADDOP_JREL(c, SETUP_EXCEPT, except);
+    compiler_use_next_block(c, body);
+    if (!compiler_push_fblock(c, EXCEPT, body))
+        return 0;
+    VISIT_SEQ(c, stmt, s->v.TryExcept.body);
+    ADDOP(c, POP_BLOCK);
+    compiler_pop_fblock(c, EXCEPT, body);
+    ADDOP_JREL(c, JUMP_FORWARD, orelse);
+    n = asdl_seq_LEN(s->v.TryExcept.handlers);
+    compiler_use_next_block(c, except);
+    for (i = 0; i < n; i++) {
+        excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET(
+                                        s->v.TryExcept.handlers, i);
+        if (!handler->v.ExceptHandler.type && i < n-1)
+            return compiler_error(c, "default 'except:' must be last");
+        c->u->u_lineno_set = false;
+        c->u->u_lineno = handler->lineno;
+        except = compiler_new_block(c);
+        if (except == NULL)
+            return 0;
+        if (handler->v.ExceptHandler.type) {
+            ADDOP(c, DUP_TOP);
+            VISIT(c, expr, handler->v.ExceptHandler.type);
+            ADDOP_I(c, COMPARE_OP, PyCmp_EXC_MATCH);
+            ADDOP_JABS(c, POP_JUMP_IF_FALSE, except);
+        }
+        ADDOP(c, POP_TOP);
+        if (handler->v.ExceptHandler.name) {
+            VISIT(c, expr, handler->v.ExceptHandler.name);
+        }
+        else {
+            ADDOP(c, POP_TOP);
+        }
+        ADDOP(c, POP_TOP);
+        VISIT_SEQ(c, stmt, handler->v.ExceptHandler.body);
+        ADDOP_JREL(c, JUMP_FORWARD, end);
+        compiler_use_next_block(c, except);
+    }
+    ADDOP(c, END_FINALLY);
+    compiler_use_next_block(c, orelse);
+    VISIT_SEQ(c, stmt, s->v.TryExcept.orelse);
+    compiler_use_next_block(c, end);
+    return 1;
 }
 
 static int
 compiler_import_as(struct compiler *c, identifier name, identifier asname)
 {
-	/* The IMPORT_NAME opcode was already generated.  This function
-	   merely needs to bind the result to a name.
-
-	   If there is a dot in name, we need to split it and emit a 
-	   LOAD_ATTR for each name.
-	*/
-	const char *src = PyString_AS_STRING(name);
-	const char *dot = strchr(src, '.');
-	if (dot) {
-		/* Consume the base module name to get the first attribute */
-		src = dot + 1;
-		while (dot) {
-			/* NB src is only defined when dot != NULL */
-			PyObject *attr;
-			dot = strchr(src, '.');
-			attr = PyString_FromStringAndSize(src, 
-					    dot ? dot - src : strlen(src));
-			if (!attr)
-				return -1;
-			ADDOP_O(c, LOAD_ATTR, attr, names);
-			Py_DECREF(attr);
-			src = dot + 1;
-		}
-	}
-	return compiler_nameop(c, asname, Store);
+    /* The IMPORT_NAME opcode was already generated.  This function
+       merely needs to bind the result to a name.
+
+       If there is a dot in name, we need to split it and emit a
+       LOAD_ATTR for each name.
+    */
+    const char *src = PyString_AS_STRING(name);
+    const char *dot = strchr(src, '.');
+    if (dot) {
+        /* Consume the base module name to get the first attribute */
+        src = dot + 1;
+        while (dot) {
+            /* NB src is only defined when dot != NULL */
+            PyObject *attr;
+            dot = strchr(src, '.');
+            attr = PyString_FromStringAndSize(src,
+                                dot ? dot - src : strlen(src));
+            if (!attr)
+                return -1;
+            ADDOP_O(c, LOAD_ATTR, attr, names);
+            Py_DECREF(attr);
+            src = dot + 1;
+        }
+    }
+    return compiler_nameop(c, asname, Store);
 }
 
 static int
 compiler_import(struct compiler *c, stmt_ty s)
 {
-	/* The Import node stores a module name like a.b.c as a single
-	   string.  This is convenient for all cases except
-	     import a.b.c as d
-	   where we need to parse that string to extract the individual
-	   module names.  
-	   XXX Perhaps change the representation to make this case simpler?
-	 */
-	int i, n = asdl_seq_LEN(s->v.Import.names);
-
-	for (i = 0; i < n; i++) {
-		alias_ty alias = (alias_ty)asdl_seq_GET(s->v.Import.names, i);
-		int r;
-		PyObject *level;
-
-		if (c->c_flags && (c->c_flags->cf_flags & CO_FUTURE_ABSOLUTE_IMPORT))
-			level = PyInt_FromLong(0);
-		else
-			level = PyInt_FromLong(-1);
-
-		if (level == NULL)
-			return 0;
-
-		ADDOP_O(c, LOAD_CONST, level, consts);
-		Py_DECREF(level);
-		ADDOP_O(c, LOAD_CONST, Py_None, consts);
-		ADDOP_NAME(c, IMPORT_NAME, alias->name, names);
-
-		if (alias->asname) {
-			r = compiler_import_as(c, alias->name, alias->asname);
-			if (!r)
-			    return r;
-		}
-		else {
-			identifier tmp = alias->name;
-			const char *base = PyString_AS_STRING(alias->name);
-			char *dot = strchr(base, '.');
-			if (dot)
-				tmp = PyString_FromStringAndSize(base, 
-								 dot - base);
-			r = compiler_nameop(c, tmp, Store);
-			if (dot) {
-				Py_DECREF(tmp);
-			}
-			if (!r)
-				return r;
-		}
-	}
-	return 1;
+    /* The Import node stores a module name like a.b.c as a single
+       string.  This is convenient for all cases except
+         import a.b.c as d
+       where we need to parse that string to extract the individual
+       module names.
+       XXX Perhaps change the representation to make this case simpler?
+     */
+    int i, n = asdl_seq_LEN(s->v.Import.names);
+
+    for (i = 0; i < n; i++) {
+        alias_ty alias = (alias_ty)asdl_seq_GET(s->v.Import.names, i);
+        int r;
+        PyObject *level;
+
+        if (c->c_flags && (c->c_flags->cf_flags & CO_FUTURE_ABSOLUTE_IMPORT))
+            level = PyInt_FromLong(0);
+        else
+            level = PyInt_FromLong(-1);
+
+        if (level == NULL)
+            return 0;
+
+        ADDOP_O(c, LOAD_CONST, level, consts);
+        Py_DECREF(level);
+        ADDOP_O(c, LOAD_CONST, Py_None, consts);
+        ADDOP_NAME(c, IMPORT_NAME, alias->name, names);
+
+        if (alias->asname) {
+            r = compiler_import_as(c, alias->name, alias->asname);
+            if (!r)
+                return r;
+        }
+        else {
+            identifier tmp = alias->name;
+            const char *base = PyString_AS_STRING(alias->name);
+            char *dot = strchr(base, '.');
+            if (dot)
+                tmp = PyString_FromStringAndSize(base,
+                                                 dot - base);
+            r = compiler_nameop(c, tmp, Store);
+            if (dot) {
+                Py_DECREF(tmp);
+            }
+            if (!r)
+                return r;
+        }
+    }
+    return 1;
 }
 
 static int
 compiler_from_import(struct compiler *c, stmt_ty s)
 {
-	int i, n = asdl_seq_LEN(s->v.ImportFrom.names);
-
-	PyObject *names = PyTuple_New(n);
-	PyObject *level;
-	static PyObject *empty_string;
-
-	if (!empty_string) {
-		empty_string = PyString_FromString("");
-		if (!empty_string)
-			return 0;
-	}
-	
-	if (!names)
-		return 0;
-
-	if (s->v.ImportFrom.level == 0 && c->c_flags &&
-	    !(c->c_flags->cf_flags & CO_FUTURE_ABSOLUTE_IMPORT))
-		level = PyInt_FromLong(-1);
-	else
-		level = PyInt_FromLong(s->v.ImportFrom.level);
-
-	if (!level) {
-		Py_DECREF(names);
-		return 0;
-	}
-
-	/* build up the names */
-	for (i = 0; i < n; i++) {
-		alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
-		Py_INCREF(alias->name);
-		PyTuple_SET_ITEM(names, i, alias->name);
-	}
-
-	if (s->lineno > c->c_future->ff_lineno && s->v.ImportFrom.module && 
-	    !strcmp(PyString_AS_STRING(s->v.ImportFrom.module), "__future__")) {
-		Py_DECREF(level);
-		Py_DECREF(names);
-		return compiler_error(c, "from __future__ imports must occur "
-				      "at the beginning of the file");
-	}
-
-	ADDOP_O(c, LOAD_CONST, level, consts);
-	Py_DECREF(level);
-	ADDOP_O(c, LOAD_CONST, names, consts);
-	Py_DECREF(names);
-	if (s->v.ImportFrom.module) {
-		ADDOP_NAME(c, IMPORT_NAME, s->v.ImportFrom.module, names);
-	}
-	else {
-		ADDOP_NAME(c, IMPORT_NAME, empty_string, names);
-	}
-	for (i = 0; i < n; i++) {
-		alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
-		identifier store_name;
-
-		if (i == 0 && *PyString_AS_STRING(alias->name) == '*') {
-			assert(n == 1);
-			ADDOP(c, IMPORT_STAR);
-			return 1;
-		}
-		    
-		ADDOP_NAME(c, IMPORT_FROM, alias->name, names);
-		store_name = alias->name;
-		if (alias->asname)
-			store_name = alias->asname;
-
-		if (!compiler_nameop(c, store_name, Store)) {
-			Py_DECREF(names);
-			return 0;
-		}
-	}
-	/* remove imported module */
-	ADDOP(c, POP_TOP);
-	return 1;
+    int i, n = asdl_seq_LEN(s->v.ImportFrom.names);
+
+    PyObject *names = PyTuple_New(n);
+    PyObject *level;
+    static PyObject *empty_string;
+
+    if (!empty_string) {
+        empty_string = PyString_FromString("");
+        if (!empty_string)
+            return 0;
+    }
+
+    if (!names)
+        return 0;
+
+    if (s->v.ImportFrom.level == 0 && c->c_flags &&
+        !(c->c_flags->cf_flags & CO_FUTURE_ABSOLUTE_IMPORT))
+        level = PyInt_FromLong(-1);
+    else
+        level = PyInt_FromLong(s->v.ImportFrom.level);
+
+    if (!level) {
+        Py_DECREF(names);
+        return 0;
+    }
+
+    /* build up the names */
+    for (i = 0; i < n; i++) {
+        alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
+        Py_INCREF(alias->name);
+        PyTuple_SET_ITEM(names, i, alias->name);
+    }
+
+    if (s->lineno > c->c_future->ff_lineno && s->v.ImportFrom.module &&
+        !strcmp(PyString_AS_STRING(s->v.ImportFrom.module), "__future__")) {
+        Py_DECREF(level);
+        Py_DECREF(names);
+        return compiler_error(c, "from __future__ imports must occur "
+                              "at the beginning of the file");
+    }
+
+    ADDOP_O(c, LOAD_CONST, level, consts);
+    Py_DECREF(level);
+    ADDOP_O(c, LOAD_CONST, names, consts);
+    Py_DECREF(names);
+    if (s->v.ImportFrom.module) {
+        ADDOP_NAME(c, IMPORT_NAME, s->v.ImportFrom.module, names);
+    }
+    else {
+        ADDOP_NAME(c, IMPORT_NAME, empty_string, names);
+    }
+    for (i = 0; i < n; i++) {
+        alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
+        identifier store_name;
+
+        if (i == 0 && *PyString_AS_STRING(alias->name) == '*') {
+            assert(n == 1);
+            ADDOP(c, IMPORT_STAR);
+            return 1;
+        }
+
+        ADDOP_NAME(c, IMPORT_FROM, alias->name, names);
+        store_name = alias->name;
+        if (alias->asname)
+            store_name = alias->asname;
+
+        if (!compiler_nameop(c, store_name, Store)) {
+            Py_DECREF(names);
+            return 0;
+        }
+    }
+    /* remove imported module */
+    ADDOP(c, POP_TOP);
+    return 1;
 }
 
 static int
 compiler_assert(struct compiler *c, stmt_ty s)
 {
-	static PyObject *assertion_error = NULL;
-	basicblock *end;
-
-	if (Py_OptimizeFlag)
-		return 1;
-	if (assertion_error == NULL) {
-		assertion_error = PyString_InternFromString("AssertionError");
-		if (assertion_error == NULL)
-			return 0;
-	}
-	if (s->v.Assert.test->kind == Tuple_kind &&
-	    asdl_seq_LEN(s->v.Assert.test->v.Tuple.elts) > 0) {
-		const char* msg =
-			"assertion is always true, perhaps remove parentheses?";
-		if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, c->c_filename,
-				       c->u->u_lineno, NULL, NULL) == -1)
-			return 0;
-	}
-	VISIT(c, expr, s->v.Assert.test);
-	end = compiler_new_block(c);
-	if (end == NULL)
-		return 0;
-	ADDOP_JABS(c, POP_JUMP_IF_TRUE, end);
-	ADDOP_O(c, LOAD_GLOBAL, assertion_error, names);
-	if (s->v.Assert.msg) {
-		VISIT(c, expr, s->v.Assert.msg);
-		ADDOP_I(c, RAISE_VARARGS, 2);
-	}
-	else {
-		ADDOP_I(c, RAISE_VARARGS, 1);
-	}
-	compiler_use_next_block(c, end);
-	return 1;
+    static PyObject *assertion_error = NULL;
+    basicblock *end;
+
+    if (Py_OptimizeFlag)
+        return 1;
+    if (assertion_error == NULL) {
+        assertion_error = PyString_InternFromString("AssertionError");
+        if (assertion_error == NULL)
+            return 0;
+    }
+    if (s->v.Assert.test->kind == Tuple_kind &&
+        asdl_seq_LEN(s->v.Assert.test->v.Tuple.elts) > 0) {
+        const char* msg =
+            "assertion is always true, perhaps remove parentheses?";
+        if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, c->c_filename,
+                               c->u->u_lineno, NULL, NULL) == -1)
+            return 0;
+    }
+    VISIT(c, expr, s->v.Assert.test);
+    end = compiler_new_block(c);
+    if (end == NULL)
+        return 0;
+    ADDOP_JABS(c, POP_JUMP_IF_TRUE, end);
+    ADDOP_O(c, LOAD_GLOBAL, assertion_error, names);
+    if (s->v.Assert.msg) {
+        VISIT(c, expr, s->v.Assert.msg);
+        ADDOP_I(c, RAISE_VARARGS, 2);
+    }
+    else {
+        ADDOP_I(c, RAISE_VARARGS, 1);
+    }
+    compiler_use_next_block(c, end);
+    return 1;
 }
 
 static int
 compiler_visit_stmt(struct compiler *c, stmt_ty s)
 {
-	int i, n;
-
-	/* Always assign a lineno to the next instruction for a stmt. */
-	c->u->u_lineno = s->lineno;
-	c->u->u_lineno_set = false;
-
-	switch (s->kind) {
-	case FunctionDef_kind:
-		return compiler_function(c, s);
-	case ClassDef_kind:
-		return compiler_class(c, s);
-	case Return_kind:
-		if (c->u->u_ste->ste_type != FunctionBlock)
-			return compiler_error(c, "'return' outside function");
-		if (s->v.Return.value) {
-			VISIT(c, expr, s->v.Return.value);
-		}
-		else
-			ADDOP_O(c, LOAD_CONST, Py_None, consts);
-		ADDOP(c, RETURN_VALUE);
-		break;
-	case Delete_kind:
-		VISIT_SEQ(c, expr, s->v.Delete.targets)
-		break;
-	case Assign_kind:
-		n = asdl_seq_LEN(s->v.Assign.targets);
-		VISIT(c, expr, s->v.Assign.value);
-		for (i = 0; i < n; i++) {
-			if (i < n - 1)
-				ADDOP(c, DUP_TOP);
-			VISIT(c, expr,
-			      (expr_ty)asdl_seq_GET(s->v.Assign.targets, i));
-		}
-		break;
-	case AugAssign_kind:
-		return compiler_augassign(c, s);
-	case Print_kind:
-		return compiler_print(c, s);
-	case For_kind:
-		return compiler_for(c, s);
-	case While_kind:
-		return compiler_while(c, s);
-	case If_kind:
-		return compiler_if(c, s);
-	case Raise_kind:
-		n = 0;
-		if (s->v.Raise.type) {
-			VISIT(c, expr, s->v.Raise.type);
-			n++;
-			if (s->v.Raise.inst) {
-				VISIT(c, expr, s->v.Raise.inst);
-				n++;
-				if (s->v.Raise.tback) {
-					VISIT(c, expr, s->v.Raise.tback);
-					n++;
-				}
-			}
-		}
-		ADDOP_I(c, RAISE_VARARGS, n);
-		break;
-	case TryExcept_kind:
-		return compiler_try_except(c, s);
-	case TryFinally_kind:
-		return compiler_try_finally(c, s);
-	case Assert_kind:
-		return compiler_assert(c, s);
-	case Import_kind:
-		return compiler_import(c, s);
-	case ImportFrom_kind:
-		return compiler_from_import(c, s);
-	case Exec_kind:
-		VISIT(c, expr, s->v.Exec.body);
-		if (s->v.Exec.globals) {
-			VISIT(c, expr, s->v.Exec.globals);
-			if (s->v.Exec.locals) {
-				VISIT(c, expr, s->v.Exec.locals);
-			} else {
-				ADDOP(c, DUP_TOP);
-			}
-		} else {
-			ADDOP_O(c, LOAD_CONST, Py_None, consts);
-			ADDOP(c, DUP_TOP);
-		}
-		ADDOP(c, EXEC_STMT);
-		break;
-	case Global_kind:
-		break;
-	case Expr_kind:
-		if (c->c_interactive && c->c_nestlevel <= 1) {
-			VISIT(c, expr, s->v.Expr.value);
-			ADDOP(c, PRINT_EXPR);
-		}
-		else if (s->v.Expr.value->kind != Str_kind &&
-			 s->v.Expr.value->kind != Num_kind) {
-			VISIT(c, expr, s->v.Expr.value);
-			ADDOP(c, POP_TOP);
-		}
-		break;
-	case Pass_kind:
-		break;
-	case Break_kind:
-		if (!compiler_in_loop(c))
-			return compiler_error(c, "'break' outside loop");
-		ADDOP(c, BREAK_LOOP);
-		break;
-	case Continue_kind:
-		return compiler_continue(c);
-	case With_kind:
-		return compiler_with(c, s);
-	}
-	return 1;
+    int i, n;
+
+    /* Always assign a lineno to the next instruction for a stmt. */
+    c->u->u_lineno = s->lineno;
+    c->u->u_lineno_set = false;
+
+    switch (s->kind) {
+    case FunctionDef_kind:
+        return compiler_function(c, s);
+    case ClassDef_kind:
+        return compiler_class(c, s);
+    case Return_kind:
+        if (c->u->u_ste->ste_type != FunctionBlock)
+            return compiler_error(c, "'return' outside function");
+        if (s->v.Return.value) {
+            VISIT(c, expr, s->v.Return.value);
+        }
+        else
+            ADDOP_O(c, LOAD_CONST, Py_None, consts);
+        ADDOP(c, RETURN_VALUE);
+        break;
+    case Delete_kind:
+        VISIT_SEQ(c, expr, s->v.Delete.targets)
+        break;
+    case Assign_kind:
+        n = asdl_seq_LEN(s->v.Assign.targets);
+        VISIT(c, expr, s->v.Assign.value);
+        for (i = 0; i < n; i++) {
+            if (i < n - 1)
+                ADDOP(c, DUP_TOP);
+            VISIT(c, expr,
+                  (expr_ty)asdl_seq_GET(s->v.Assign.targets, i));
+        }
+        break;
+    case AugAssign_kind:
+        return compiler_augassign(c, s);
+    case Print_kind:
+        return compiler_print(c, s);
+    case For_kind:
+        return compiler_for(c, s);
+    case While_kind:
+        return compiler_while(c, s);
+    case If_kind:
+        return compiler_if(c, s);
+    case Raise_kind:
+        n = 0;
+        if (s->v.Raise.type) {
+            VISIT(c, expr, s->v.Raise.type);
+            n++;
+            if (s->v.Raise.inst) {
+                VISIT(c, expr, s->v.Raise.inst);
+                n++;
+                if (s->v.Raise.tback) {
+                    VISIT(c, expr, s->v.Raise.tback);
+                    n++;
+                }
+            }
+        }
+        ADDOP_I(c, RAISE_VARARGS, n);
+        break;
+    case TryExcept_kind:
+        return compiler_try_except(c, s);
+    case TryFinally_kind:
+        return compiler_try_finally(c, s);
+    case Assert_kind:
+        return compiler_assert(c, s);
+    case Import_kind:
+        return compiler_import(c, s);
+    case ImportFrom_kind:
+        return compiler_from_import(c, s);
+    case Exec_kind:
+        VISIT(c, expr, s->v.Exec.body);
+        if (s->v.Exec.globals) {
+            VISIT(c, expr, s->v.Exec.globals);
+            if (s->v.Exec.locals) {
+                VISIT(c, expr, s->v.Exec.locals);
+            } else {
+                ADDOP(c, DUP_TOP);
+            }
+        } else {
+            ADDOP_O(c, LOAD_CONST, Py_None, consts);
+            ADDOP(c, DUP_TOP);
+        }
+        ADDOP(c, EXEC_STMT);
+        break;
+    case Global_kind:
+        break;
+    case Expr_kind:
+        if (c->c_interactive && c->c_nestlevel <= 1) {
+            VISIT(c, expr, s->v.Expr.value);
+            ADDOP(c, PRINT_EXPR);
+        }
+        else if (s->v.Expr.value->kind != Str_kind &&
+                 s->v.Expr.value->kind != Num_kind) {
+            VISIT(c, expr, s->v.Expr.value);
+            ADDOP(c, POP_TOP);
+        }
+        break;
+    case Pass_kind:
+        break;
+    case Break_kind:
+        if (!compiler_in_loop(c))
+            return compiler_error(c, "'break' outside loop");
+        ADDOP(c, BREAK_LOOP);
+        break;
+    case Continue_kind:
+        return compiler_continue(c);
+    case With_kind:
+        return compiler_with(c, s);
+    }
+    return 1;
 }
 
 static int
 unaryop(unaryop_ty op)
 {
-	switch (op) {
-	case Invert:
-		return UNARY_INVERT;
-	case Not:
-		return UNARY_NOT;
-	case UAdd:
-		return UNARY_POSITIVE;
-	case USub:
-		return UNARY_NEGATIVE;
-	default:
-		PyErr_Format(PyExc_SystemError,
-			"unary op %d should not be possible", op);
-		return 0;
-	}
+    switch (op) {
+    case Invert:
+        return UNARY_INVERT;
+    case Not:
+        return UNARY_NOT;
+    case UAdd:
+        return UNARY_POSITIVE;
+    case USub:
+        return UNARY_NEGATIVE;
+    default:
+        PyErr_Format(PyExc_SystemError,
+            "unary op %d should not be possible", op);
+        return 0;
+    }
 }
 
 static int
 binop(struct compiler *c, operator_ty op)
 {
-	switch (op) {
-	case Add:
-		return BINARY_ADD;
-	case Sub:
-		return BINARY_SUBTRACT;
-	case Mult:
-		return BINARY_MULTIPLY;
-	case Div:
-		if (c->c_flags && c->c_flags->cf_flags & CO_FUTURE_DIVISION)
-			return BINARY_TRUE_DIVIDE;
-		else
-			return BINARY_DIVIDE;
-	case Mod:
-		return BINARY_MODULO;
-	case Pow:
-		return BINARY_POWER;
-	case LShift:
-		return BINARY_LSHIFT;
-	case RShift:
-		return BINARY_RSHIFT;
-	case BitOr:
-		return BINARY_OR;
-	case BitXor:
-		return BINARY_XOR;
-	case BitAnd:
-		return BINARY_AND;
-	case FloorDiv:
-		return BINARY_FLOOR_DIVIDE;
-	default:
-		PyErr_Format(PyExc_SystemError,
-			"binary op %d should not be possible", op);
-		return 0;
-	}
+    switch (op) {
+    case Add:
+        return BINARY_ADD;
+    case Sub:
+        return BINARY_SUBTRACT;
+    case Mult:
+        return BINARY_MULTIPLY;
+    case Div:
+        if (c->c_flags && c->c_flags->cf_flags & CO_FUTURE_DIVISION)
+            return BINARY_TRUE_DIVIDE;
+        else
+            return BINARY_DIVIDE;
+    case Mod:
+        return BINARY_MODULO;
+    case Pow:
+        return BINARY_POWER;
+    case LShift:
+        return BINARY_LSHIFT;
+    case RShift:
+        return BINARY_RSHIFT;
+    case BitOr:
+        return BINARY_OR;
+    case BitXor:
+        return BINARY_XOR;
+    case BitAnd:
+        return BINARY_AND;
+    case FloorDiv:
+        return BINARY_FLOOR_DIVIDE;
+    default:
+        PyErr_Format(PyExc_SystemError,
+            "binary op %d should not be possible", op);
+        return 0;
+    }
 }
 
 static int
 cmpop(cmpop_ty op)
 {
-	switch (op) {
-	case Eq:
-		return PyCmp_EQ;
-	case NotEq:
-		return PyCmp_NE;
-	case Lt:
-		return PyCmp_LT;
-	case LtE:
-		return PyCmp_LE;
-	case Gt:
-		return PyCmp_GT;
-	case GtE:
-		return PyCmp_GE;
-	case Is:
-		return PyCmp_IS;
-	case IsNot:
-		return PyCmp_IS_NOT;
-	case In:
-		return PyCmp_IN;
-	case NotIn:
-		return PyCmp_NOT_IN;
-	default:
-		return PyCmp_BAD;
-	}
+    switch (op) {
+    case Eq:
+        return PyCmp_EQ;
+    case NotEq:
+        return PyCmp_NE;
+    case Lt:
+        return PyCmp_LT;
+    case LtE:
+        return PyCmp_LE;
+    case Gt:
+        return PyCmp_GT;
+    case GtE:
+        return PyCmp_GE;
+    case Is:
+        return PyCmp_IS;
+    case IsNot:
+        return PyCmp_IS_NOT;
+    case In:
+        return PyCmp_IN;
+    case NotIn:
+        return PyCmp_NOT_IN;
+    default:
+        return PyCmp_BAD;
+    }
 }
 
 static int
 inplace_binop(struct compiler *c, operator_ty op)
 {
-	switch (op) {
-	case Add:
-		return INPLACE_ADD;
-	case Sub:
-		return INPLACE_SUBTRACT;
-	case Mult:
-		return INPLACE_MULTIPLY;
-	case Div:
-		if (c->c_flags && c->c_flags->cf_flags & CO_FUTURE_DIVISION)
-			return INPLACE_TRUE_DIVIDE;
-		else
-			return INPLACE_DIVIDE;
-	case Mod:
-		return INPLACE_MODULO;
-	case Pow:
-		return INPLACE_POWER;
-	case LShift:
-		return INPLACE_LSHIFT;
-	case RShift:
-		return INPLACE_RSHIFT;
-	case BitOr:
-		return INPLACE_OR;
-	case BitXor:
-		return INPLACE_XOR;
-	case BitAnd:
-		return INPLACE_AND;
-	case FloorDiv:
-		return INPLACE_FLOOR_DIVIDE;
-	default:
-		PyErr_Format(PyExc_SystemError,
-			"inplace binary op %d should not be possible", op);
-		return 0;
-	}
+    switch (op) {
+    case Add:
+        return INPLACE_ADD;
+    case Sub:
+        return INPLACE_SUBTRACT;
+    case Mult:
+        return INPLACE_MULTIPLY;
+    case Div:
+        if (c->c_flags && c->c_flags->cf_flags & CO_FUTURE_DIVISION)
+            return INPLACE_TRUE_DIVIDE;
+        else
+            return INPLACE_DIVIDE;
+    case Mod:
+        return INPLACE_MODULO;
+    case Pow:
+        return INPLACE_POWER;
+    case LShift:
+        return INPLACE_LSHIFT;
+    case RShift:
+        return INPLACE_RSHIFT;
+    case BitOr:
+        return INPLACE_OR;
+    case BitXor:
+        return INPLACE_XOR;
+    case BitAnd:
+        return INPLACE_AND;
+    case FloorDiv:
+        return INPLACE_FLOOR_DIVIDE;
+    default:
+        PyErr_Format(PyExc_SystemError,
+            "inplace binary op %d should not be possible", op);
+        return 0;
+    }
 }
 
 static int
 compiler_nameop(struct compiler *c, identifier name, expr_context_ty ctx)
 {
-	int op, scope, arg;
-	enum { OP_FAST, OP_GLOBAL, OP_DEREF, OP_NAME } optype;
-
-	PyObject *dict = c->u->u_names;
-	PyObject *mangled;
-	/* XXX AugStore isn't used anywhere! */
-
-	mangled = _Py_Mangle(c->u->u_private, name);
-	if (!mangled)
-		return 0;
-
-	op = 0;
-	optype = OP_NAME;
-	scope = PyST_GetScope(c->u->u_ste, mangled);
-	switch (scope) {
-	case FREE:
-		dict = c->u->u_freevars;
-		optype = OP_DEREF;
-		break;
-	case CELL:
-		dict = c->u->u_cellvars;
-		optype = OP_DEREF;
-		break;
-	case LOCAL:
-		if (c->u->u_ste->ste_type == FunctionBlock)
-			optype = OP_FAST;
-		break;
-	case GLOBAL_IMPLICIT:
-		if (c->u->u_ste->ste_type == FunctionBlock &&
-			!c->u->u_ste->ste_unoptimized)
-			optype = OP_GLOBAL;
-		break;
-	case GLOBAL_EXPLICIT:
-		optype = OP_GLOBAL;
-		break;
-	default:
-		/* scope can be 0 */
-		break;
-	}
-
-	/* XXX Leave assert here, but handle __doc__ and the like better */
-	assert(scope || PyString_AS_STRING(name)[0] == '_');
-
-	switch (optype) {
-	case OP_DEREF:
-		switch (ctx) {
-		case Load: op = LOAD_DEREF; break;
-		case Store: op = STORE_DEREF; break;
-		case AugLoad:
-		case AugStore:
-			break;
-		case Del:
-			PyErr_Format(PyExc_SyntaxError,
-				     "can not delete variable '%s' referenced "
-				     "in nested scope",
-				     PyString_AS_STRING(name));
-			Py_DECREF(mangled);
-			return 0;
-		case Param:
-		default:
-			PyErr_SetString(PyExc_SystemError,
-					"param invalid for deref variable");
-			return 0;
-		}
-		break;
-	case OP_FAST:
-		switch (ctx) {
-		case Load: op = LOAD_FAST; break;
-		case Store: op = STORE_FAST; break;
-		case Del: op = DELETE_FAST; break;
-		case AugLoad:
-		case AugStore:
-			break;
-		case Param:
-		default:
-			PyErr_SetString(PyExc_SystemError,
-					"param invalid for local variable");
-			return 0;
-		}
-		ADDOP_O(c, op, mangled, varnames);
-		Py_DECREF(mangled);
-		return 1;
-	case OP_GLOBAL:
-		switch (ctx) {
-		case Load: op = LOAD_GLOBAL; break;
-		case Store: op = STORE_GLOBAL; break;
-		case Del: op = DELETE_GLOBAL; break;
-		case AugLoad:
-		case AugStore:
-			break;
-		case Param:
-		default:
-			PyErr_SetString(PyExc_SystemError,
-					"param invalid for global variable");
-			return 0;
-		}
-		break;
-	case OP_NAME:
-		switch (ctx) {
-		case Load: op = LOAD_NAME; break;
-		case Store: op = STORE_NAME; break;
-		case Del: op = DELETE_NAME; break;
-		case AugLoad:
-		case AugStore:
-			break;
-		case Param:
-		default:
-			PyErr_SetString(PyExc_SystemError,
-					"param invalid for name variable");
-			return 0;
-		}
-		break;
-	}
-
-	assert(op);
-	arg = compiler_add_o(c, dict, mangled);
-	Py_DECREF(mangled);
-	if (arg < 0)
-		return 0;
-	return compiler_addop_i(c, op, arg);
+    int op, scope, arg;
+    enum { OP_FAST, OP_GLOBAL, OP_DEREF, OP_NAME } optype;
+
+    PyObject *dict = c->u->u_names;
+    PyObject *mangled;
+    /* XXX AugStore isn't used anywhere! */
+
+    mangled = _Py_Mangle(c->u->u_private, name);
+    if (!mangled)
+        return 0;
+
+    op = 0;
+    optype = OP_NAME;
+    scope = PyST_GetScope(c->u->u_ste, mangled);
+    switch (scope) {
+    case FREE:
+        dict = c->u->u_freevars;
+        optype = OP_DEREF;
+        break;
+    case CELL:
+        dict = c->u->u_cellvars;
+        optype = OP_DEREF;
+        break;
+    case LOCAL:
+        if (c->u->u_ste->ste_type == FunctionBlock)
+            optype = OP_FAST;
+        break;
+    case GLOBAL_IMPLICIT:
+        if (c->u->u_ste->ste_type == FunctionBlock &&
+            !c->u->u_ste->ste_unoptimized)
+            optype = OP_GLOBAL;
+        break;
+    case GLOBAL_EXPLICIT:
+        optype = OP_GLOBAL;
+        break;
+    default:
+        /* scope can be 0 */
+        break;
+    }
+
+    /* XXX Leave assert here, but handle __doc__ and the like better */
+    assert(scope || PyString_AS_STRING(name)[0] == '_');
+
+    switch (optype) {
+    case OP_DEREF:
+        switch (ctx) {
+        case Load: op = LOAD_DEREF; break;
+        case Store: op = STORE_DEREF; break;
+        case AugLoad:
+        case AugStore:
+            break;
+        case Del:
+            PyErr_Format(PyExc_SyntaxError,
+                         "can not delete variable '%s' referenced "
+                         "in nested scope",
+                         PyString_AS_STRING(name));
+            Py_DECREF(mangled);
+            return 0;
+        case Param:
+        default:
+            PyErr_SetString(PyExc_SystemError,
+                            "param invalid for deref variable");
+            return 0;
+        }
+        break;
+    case OP_FAST:
+        switch (ctx) {
+        case Load: op = LOAD_FAST; break;
+        case Store: op = STORE_FAST; break;
+        case Del: op = DELETE_FAST; break;
+        case AugLoad:
+        case AugStore:
+            break;
+        case Param:
+        default:
+            PyErr_SetString(PyExc_SystemError,
+                            "param invalid for local variable");
+            return 0;
+        }
+        ADDOP_O(c, op, mangled, varnames);
+        Py_DECREF(mangled);
+        return 1;
+    case OP_GLOBAL:
+        switch (ctx) {
+        case Load: op = LOAD_GLOBAL; break;
+        case Store: op = STORE_GLOBAL; break;
+        case Del: op = DELETE_GLOBAL; break;
+        case AugLoad:
+        case AugStore:
+            break;
+        case Param:
+        default:
+            PyErr_SetString(PyExc_SystemError,
+                            "param invalid for global variable");
+            return 0;
+        }
+        break;
+    case OP_NAME:
+        switch (ctx) {
+        case Load: op = LOAD_NAME; break;
+        case Store: op = STORE_NAME; break;
+        case Del: op = DELETE_NAME; break;
+        case AugLoad:
+        case AugStore:
+            break;
+        case Param:
+        default:
+            PyErr_SetString(PyExc_SystemError,
+                            "param invalid for name variable");
+            return 0;
+        }
+        break;
+    }
+
+    assert(op);
+    arg = compiler_add_o(c, dict, mangled);
+    Py_DECREF(mangled);
+    if (arg < 0)
+        return 0;
+    return compiler_addop_i(c, op, arg);
 }
 
 static int
 compiler_boolop(struct compiler *c, expr_ty e)
 {
-	basicblock *end;
-	int jumpi, i, n;
-	asdl_seq *s;
-
-	assert(e->kind == BoolOp_kind);
-	if (e->v.BoolOp.op == And)
-		jumpi = JUMP_IF_FALSE_OR_POP;
-	else
-		jumpi = JUMP_IF_TRUE_OR_POP;
-	end = compiler_new_block(c);
-	if (end == NULL)
-		return 0;
-	s = e->v.BoolOp.values;
-	n = asdl_seq_LEN(s) - 1;
-	assert(n >= 0);
-	for (i = 0; i < n; ++i) {
-		VISIT(c, expr, (expr_ty)asdl_seq_GET(s, i));
-		ADDOP_JABS(c, jumpi, end);
-	}
-	VISIT(c, expr, (expr_ty)asdl_seq_GET(s, n));
-	compiler_use_next_block(c, end);
-	return 1;
+    basicblock *end;
+    int jumpi, i, n;
+    asdl_seq *s;
+
+    assert(e->kind == BoolOp_kind);
+    if (e->v.BoolOp.op == And)
+        jumpi = JUMP_IF_FALSE_OR_POP;
+    else
+        jumpi = JUMP_IF_TRUE_OR_POP;
+    end = compiler_new_block(c);
+    if (end == NULL)
+        return 0;
+    s = e->v.BoolOp.values;
+    n = asdl_seq_LEN(s) - 1;
+    assert(n >= 0);
+    for (i = 0; i < n; ++i) {
+        VISIT(c, expr, (expr_ty)asdl_seq_GET(s, i));
+        ADDOP_JABS(c, jumpi, end);
+    }
+    VISIT(c, expr, (expr_ty)asdl_seq_GET(s, n));
+    compiler_use_next_block(c, end);
+    return 1;
 }
 
 static int
 compiler_list(struct compiler *c, expr_ty e)
 {
-	int n = asdl_seq_LEN(e->v.List.elts);
-	if (e->v.List.ctx == Store) {
-		ADDOP_I(c, UNPACK_SEQUENCE, n);
-	}
-	VISIT_SEQ(c, expr, e->v.List.elts);
-	if (e->v.List.ctx == Load) {
-		ADDOP_I(c, BUILD_LIST, n);
-	}
-	return 1;
+    int n = asdl_seq_LEN(e->v.List.elts);
+    if (e->v.List.ctx == Store) {
+        ADDOP_I(c, UNPACK_SEQUENCE, n);
+    }
+    VISIT_SEQ(c, expr, e->v.List.elts);
+    if (e->v.List.ctx == Load) {
+        ADDOP_I(c, BUILD_LIST, n);
+    }
+    return 1;
 }
 
 static int
 compiler_tuple(struct compiler *c, expr_ty e)
 {
-	int n = asdl_seq_LEN(e->v.Tuple.elts);
-	if (e->v.Tuple.ctx == Store) {
-		ADDOP_I(c, UNPACK_SEQUENCE, n);
-	}
-	VISIT_SEQ(c, expr, e->v.Tuple.elts);
-	if (e->v.Tuple.ctx == Load) {
-		ADDOP_I(c, BUILD_TUPLE, n);
-	}
-	return 1;
+    int n = asdl_seq_LEN(e->v.Tuple.elts);
+    if (e->v.Tuple.ctx == Store) {
+        ADDOP_I(c, UNPACK_SEQUENCE, n);
+    }
+    VISIT_SEQ(c, expr, e->v.Tuple.elts);
+    if (e->v.Tuple.ctx == Load) {
+        ADDOP_I(c, BUILD_TUPLE, n);
+    }
+    return 1;
 }
 
 static int
 compiler_compare(struct compiler *c, expr_ty e)
 {
-	int i, n;
-	basicblock *cleanup = NULL;
-
-	/* XXX the logic can be cleaned up for 1 or multiple comparisons */
-	VISIT(c, expr, e->v.Compare.left);
-	n = asdl_seq_LEN(e->v.Compare.ops);
-	assert(n > 0);
-	if (n > 1) {
-		cleanup = compiler_new_block(c);
-		if (cleanup == NULL)
-		    return 0;
-		VISIT(c, expr, 
-			(expr_ty)asdl_seq_GET(e->v.Compare.comparators, 0));
-	}
-	for (i = 1; i < n; i++) {
-		ADDOP(c, DUP_TOP);
-		ADDOP(c, ROT_THREE);
-		ADDOP_I(c, COMPARE_OP,
-			cmpop((cmpop_ty)(asdl_seq_GET(
-						  e->v.Compare.ops, i - 1))));
-		ADDOP_JABS(c, JUMP_IF_FALSE_OR_POP, cleanup);
-		NEXT_BLOCK(c);
-		if (i < (n - 1))
-		    VISIT(c, expr, 
-			    (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i));
-	}
-	VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n - 1));
-	ADDOP_I(c, COMPARE_OP,
-	       cmpop((cmpop_ty)(asdl_seq_GET(e->v.Compare.ops, n - 1))));
-	if (n > 1) {
-		basicblock *end = compiler_new_block(c);
-		if (end == NULL)
-		    return 0;
-		ADDOP_JREL(c, JUMP_FORWARD, end);
-		compiler_use_next_block(c, cleanup);
-		ADDOP(c, ROT_TWO);
-		ADDOP(c, POP_TOP);
-		compiler_use_next_block(c, end);
-	}
-	return 1;
+    int i, n;
+    basicblock *cleanup = NULL;
+
+    /* XXX the logic can be cleaned up for 1 or multiple comparisons */
+    VISIT(c, expr, e->v.Compare.left);
+    n = asdl_seq_LEN(e->v.Compare.ops);
+    assert(n > 0);
+    if (n > 1) {
+        cleanup = compiler_new_block(c);
+        if (cleanup == NULL)
+            return 0;
+        VISIT(c, expr,
+            (expr_ty)asdl_seq_GET(e->v.Compare.comparators, 0));
+    }
+    for (i = 1; i < n; i++) {
+        ADDOP(c, DUP_TOP);
+        ADDOP(c, ROT_THREE);
+        ADDOP_I(c, COMPARE_OP,
+            cmpop((cmpop_ty)(asdl_seq_GET(
+                                      e->v.Compare.ops, i - 1))));
+        ADDOP_JABS(c, JUMP_IF_FALSE_OR_POP, cleanup);
+        NEXT_BLOCK(c);
+        if (i < (n - 1))
+            VISIT(c, expr,
+                (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i));
+    }
+    VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Compare.comparators, n - 1));
+    ADDOP_I(c, COMPARE_OP,
+           cmpop((cmpop_ty)(asdl_seq_GET(e->v.Compare.ops, n - 1))));
+    if (n > 1) {
+        basicblock *end = compiler_new_block(c);
+        if (end == NULL)
+            return 0;
+        ADDOP_JREL(c, JUMP_FORWARD, end);
+        compiler_use_next_block(c, cleanup);
+        ADDOP(c, ROT_TWO);
+        ADDOP(c, POP_TOP);
+        compiler_use_next_block(c, end);
+    }
+    return 1;
 }
 
 static int
 compiler_call(struct compiler *c, expr_ty e)
 {
-	int n, code = 0;
-
-	VISIT(c, expr, e->v.Call.func);
-	n = asdl_seq_LEN(e->v.Call.args);
-	VISIT_SEQ(c, expr, e->v.Call.args);
-	if (e->v.Call.keywords) {
-		VISIT_SEQ(c, keyword, e->v.Call.keywords);
-		n |= asdl_seq_LEN(e->v.Call.keywords) << 8;
-	}
-	if (e->v.Call.starargs) {
-		VISIT(c, expr, e->v.Call.starargs);
-		code |= 1;
-	}
-	if (e->v.Call.kwargs) {
-		VISIT(c, expr, e->v.Call.kwargs);
-		code |= 2;
-	}
-	switch (code) {
-	case 0:
-		ADDOP_I(c, CALL_FUNCTION, n);
-		break;
-	case 1:
-		ADDOP_I(c, CALL_FUNCTION_VAR, n);
-		break;
-	case 2:
-		ADDOP_I(c, CALL_FUNCTION_KW, n);
-		break;
-	case 3:
-		ADDOP_I(c, CALL_FUNCTION_VAR_KW, n);
-		break;
-	}
-	return 1;
+    int n, code = 0;
+
+    VISIT(c, expr, e->v.Call.func);
+    n = asdl_seq_LEN(e->v.Call.args);
+    VISIT_SEQ(c, expr, e->v.Call.args);
+    if (e->v.Call.keywords) {
+        VISIT_SEQ(c, keyword, e->v.Call.keywords);
+        n |= asdl_seq_LEN(e->v.Call.keywords) << 8;
+    }
+    if (e->v.Call.starargs) {
+        VISIT(c, expr, e->v.Call.starargs);
+        code |= 1;
+    }
+    if (e->v.Call.kwargs) {
+        VISIT(c, expr, e->v.Call.kwargs);
+        code |= 2;
+    }
+    switch (code) {
+    case 0:
+        ADDOP_I(c, CALL_FUNCTION, n);
+        break;
+    case 1:
+        ADDOP_I(c, CALL_FUNCTION_VAR, n);
+        break;
+    case 2:
+        ADDOP_I(c, CALL_FUNCTION_KW, n);
+        break;
+    case 3:
+        ADDOP_I(c, CALL_FUNCTION_VAR_KW, n);
+        break;
+    }
+    return 1;
 }
 
 static int
 compiler_listcomp_generator(struct compiler *c, asdl_seq *generators,
-			    int gen_index, expr_ty elt)
-{
-	/* generate code for the iterator, then each of the ifs,
-	   and then write to the element */
-
-	comprehension_ty l;
-	basicblock *start, *anchor, *skip, *if_cleanup;
-	int i, n;
-
-	start = compiler_new_block(c);
-	skip = compiler_new_block(c);
-	if_cleanup = compiler_new_block(c);
-	anchor = compiler_new_block(c);
-
-	if (start == NULL || skip == NULL || if_cleanup == NULL ||
-		anchor == NULL)
-	    return 0;
-
-	l = (comprehension_ty)asdl_seq_GET(generators, gen_index);
-	VISIT(c, expr, l->iter);
-	ADDOP(c, GET_ITER);
-	compiler_use_next_block(c, start);
-	ADDOP_JREL(c, FOR_ITER, anchor);
-	NEXT_BLOCK(c);
-	VISIT(c, expr, l->target);
-
-	/* XXX this needs to be cleaned up...a lot! */
-	n = asdl_seq_LEN(l->ifs);
-	for (i = 0; i < n; i++) {
-		expr_ty e = (expr_ty)asdl_seq_GET(l->ifs, i);
-		VISIT(c, expr, e);
-		ADDOP_JABS(c, POP_JUMP_IF_FALSE, if_cleanup);
-		NEXT_BLOCK(c);
-	} 
-
-	if (++gen_index < asdl_seq_LEN(generators))
-	    if (!compiler_listcomp_generator(c, generators, gen_index, elt))
-		return 0;
-
-	/* only append after the last for generator */
-	if (gen_index >= asdl_seq_LEN(generators)) {
-	    VISIT(c, expr, elt);
-	    ADDOP_I(c, LIST_APPEND, gen_index+1);
-
-	    compiler_use_next_block(c, skip);
-	}
-	compiler_use_next_block(c, if_cleanup);
-	ADDOP_JABS(c, JUMP_ABSOLUTE, start);
-	compiler_use_next_block(c, anchor);
-	
-	return 1;
+                            int gen_index, expr_ty elt)
+{
+    /* generate code for the iterator, then each of the ifs,
+       and then write to the element */
+
+    comprehension_ty l;
+    basicblock *start, *anchor, *skip, *if_cleanup;
+    int i, n;
+
+    start = compiler_new_block(c);
+    skip = compiler_new_block(c);
+    if_cleanup = compiler_new_block(c);
+    anchor = compiler_new_block(c);
+
+    if (start == NULL || skip == NULL || if_cleanup == NULL ||
+        anchor == NULL)
+        return 0;
+
+    l = (comprehension_ty)asdl_seq_GET(generators, gen_index);
+    VISIT(c, expr, l->iter);
+    ADDOP(c, GET_ITER);
+    compiler_use_next_block(c, start);
+    ADDOP_JREL(c, FOR_ITER, anchor);
+    NEXT_BLOCK(c);
+    VISIT(c, expr, l->target);
+
+    /* XXX this needs to be cleaned up...a lot! */
+    n = asdl_seq_LEN(l->ifs);
+    for (i = 0; i < n; i++) {
+        expr_ty e = (expr_ty)asdl_seq_GET(l->ifs, i);
+        VISIT(c, expr, e);
+        ADDOP_JABS(c, POP_JUMP_IF_FALSE, if_cleanup);
+        NEXT_BLOCK(c);
+    }
+
+    if (++gen_index < asdl_seq_LEN(generators))
+        if (!compiler_listcomp_generator(c, generators, gen_index, elt))
+        return 0;
+
+    /* only append after the last for generator */
+    if (gen_index >= asdl_seq_LEN(generators)) {
+        VISIT(c, expr, elt);
+        ADDOP_I(c, LIST_APPEND, gen_index+1);
+
+        compiler_use_next_block(c, skip);
+    }
+    compiler_use_next_block(c, if_cleanup);
+    ADDOP_JABS(c, JUMP_ABSOLUTE, start);
+    compiler_use_next_block(c, anchor);
+
+    return 1;
 }
 
 static int
 compiler_listcomp(struct compiler *c, expr_ty e)
 {
-	assert(e->kind == ListComp_kind);
-	ADDOP_I(c, BUILD_LIST, 0);
-	return compiler_listcomp_generator(c, e->v.ListComp.generators, 0,
-					   e->v.ListComp.elt);
+    assert(e->kind == ListComp_kind);
+    ADDOP_I(c, BUILD_LIST, 0);
+    return compiler_listcomp_generator(c, e->v.ListComp.generators, 0,
+                                       e->v.ListComp.elt);
 }
 
 /* Dict and set comprehensions and generator expressions work by creating a
@@ -2670,204 +2670,204 @@ compiler_listcomp(struct compiler *c, expr_ty e)
 */
 
 static int
-compiler_comprehension_generator(struct compiler *c, 
-				 asdl_seq *generators, int gen_index, 
-				 expr_ty elt, expr_ty val, int type)
-{
-	/* generate code for the iterator, then each of the ifs,
-	   and then write to the element */
-
-	comprehension_ty gen;
-	basicblock *start, *anchor, *skip, *if_cleanup;
-	int i, n;
-
-	start = compiler_new_block(c);
-	skip = compiler_new_block(c);
-	if_cleanup = compiler_new_block(c);
-	anchor = compiler_new_block(c);
-
-	if (start == NULL || skip == NULL || if_cleanup == NULL ||
-	    anchor == NULL)
-		return 0;
-
-	gen = (comprehension_ty)asdl_seq_GET(generators, gen_index);
-	
-	if (gen_index == 0) {
-		/* Receive outermost iter as an implicit argument */
-		c->u->u_argcount = 1;
-		ADDOP_I(c, LOAD_FAST, 0);
-	}
-	else {
-		/* Sub-iter - calculate on the fly */
-		VISIT(c, expr, gen->iter);
-		ADDOP(c, GET_ITER);
-	}
-	compiler_use_next_block(c, start);
-	ADDOP_JREL(c, FOR_ITER, anchor);
-	NEXT_BLOCK(c);
-	VISIT(c, expr, gen->target);
-
-	/* XXX this needs to be cleaned up...a lot! */
-	n = asdl_seq_LEN(gen->ifs);
-	for (i = 0; i < n; i++) {
-		expr_ty e = (expr_ty)asdl_seq_GET(gen->ifs, i);
-		VISIT(c, expr, e);
-		ADDOP_JABS(c, POP_JUMP_IF_FALSE, if_cleanup);
-		NEXT_BLOCK(c);
-	}
-
-	if (++gen_index < asdl_seq_LEN(generators))
-		if (!compiler_comprehension_generator(c, 
-						      generators, gen_index,
-						      elt, val, type))
-		return 0;
-
-	/* only append after the last for generator */
-	if (gen_index >= asdl_seq_LEN(generators)) {
-		/* comprehension specific code */
-		switch (type) {
-		case COMP_GENEXP:
-			VISIT(c, expr, elt);
-			ADDOP(c, YIELD_VALUE);
-			ADDOP(c, POP_TOP);
-			break;
-		case COMP_SETCOMP:
-			VISIT(c, expr, elt);
-			ADDOP_I(c, SET_ADD, gen_index + 1);
-			break;
-		case COMP_DICTCOMP:
-			/* With 'd[k] = v', v is evaluated before k, so we do
-			   the same. */
-			VISIT(c, expr, val);
-			VISIT(c, expr, elt);
-			ADDOP_I(c, MAP_ADD, gen_index + 1);
-			break;
-		default:
-			return 0;
-		}
-
-		compiler_use_next_block(c, skip);
-	}
-	compiler_use_next_block(c, if_cleanup);
-	ADDOP_JABS(c, JUMP_ABSOLUTE, start);
-	compiler_use_next_block(c, anchor);
-
-	return 1;
+compiler_comprehension_generator(struct compiler *c,
+                                 asdl_seq *generators, int gen_index,
+                                 expr_ty elt, expr_ty val, int type)
+{
+    /* generate code for the iterator, then each of the ifs,
+       and then write to the element */
+
+    comprehension_ty gen;
+    basicblock *start, *anchor, *skip, *if_cleanup;
+    int i, n;
+
+    start = compiler_new_block(c);
+    skip = compiler_new_block(c);
+    if_cleanup = compiler_new_block(c);
+    anchor = compiler_new_block(c);
+
+    if (start == NULL || skip == NULL || if_cleanup == NULL ||
+        anchor == NULL)
+        return 0;
+
+    gen = (comprehension_ty)asdl_seq_GET(generators, gen_index);
+
+    if (gen_index == 0) {
+        /* Receive outermost iter as an implicit argument */
+        c->u->u_argcount = 1;
+        ADDOP_I(c, LOAD_FAST, 0);
+    }
+    else {
+        /* Sub-iter - calculate on the fly */
+        VISIT(c, expr, gen->iter);
+        ADDOP(c, GET_ITER);
+    }
+    compiler_use_next_block(c, start);
+    ADDOP_JREL(c, FOR_ITER, anchor);
+    NEXT_BLOCK(c);
+    VISIT(c, expr, gen->target);
+
+    /* XXX this needs to be cleaned up...a lot! */
+    n = asdl_seq_LEN(gen->ifs);
+    for (i = 0; i < n; i++) {
+        expr_ty e = (expr_ty)asdl_seq_GET(gen->ifs, i);
+        VISIT(c, expr, e);
+        ADDOP_JABS(c, POP_JUMP_IF_FALSE, if_cleanup);
+        NEXT_BLOCK(c);
+    }
+
+    if (++gen_index < asdl_seq_LEN(generators))
+        if (!compiler_comprehension_generator(c,
+                                              generators, gen_index,
+                                              elt, val, type))
+        return 0;
+
+    /* only append after the last for generator */
+    if (gen_index >= asdl_seq_LEN(generators)) {
+        /* comprehension specific code */
+        switch (type) {
+        case COMP_GENEXP:
+            VISIT(c, expr, elt);
+            ADDOP(c, YIELD_VALUE);
+            ADDOP(c, POP_TOP);
+            break;
+        case COMP_SETCOMP:
+            VISIT(c, expr, elt);
+            ADDOP_I(c, SET_ADD, gen_index + 1);
+            break;
+        case COMP_DICTCOMP:
+            /* With 'd[k] = v', v is evaluated before k, so we do
+               the same. */
+            VISIT(c, expr, val);
+            VISIT(c, expr, elt);
+            ADDOP_I(c, MAP_ADD, gen_index + 1);
+            break;
+        default:
+            return 0;
+        }
+
+        compiler_use_next_block(c, skip);
+    }
+    compiler_use_next_block(c, if_cleanup);
+    ADDOP_JABS(c, JUMP_ABSOLUTE, start);
+    compiler_use_next_block(c, anchor);
+
+    return 1;
 }
 
 static int
 compiler_comprehension(struct compiler *c, expr_ty e, int type, identifier name,
-		       asdl_seq *generators, expr_ty elt, expr_ty val)
-{
-	PyCodeObject *co = NULL;
-	expr_ty outermost_iter;
-
-	outermost_iter = ((comprehension_ty)
-			  asdl_seq_GET(generators, 0))->iter;
-
-	if (!compiler_enter_scope(c, name, (void *)e, e->lineno))
-		goto error;
-	
-	if (type != COMP_GENEXP) {
-		int op;
-		switch (type) {
-		case COMP_SETCOMP:
-			op = BUILD_SET;
-			break;
-		case COMP_DICTCOMP:
-			op = BUILD_MAP;
-			break;
-		default:
-			PyErr_Format(PyExc_SystemError,
-				     "unknown comprehension type %d", type);
-			goto error_in_scope;
-		}
-
-		ADDOP_I(c, op, 0);
-	}
-	
-	if (!compiler_comprehension_generator(c, generators, 0, elt,
-					      val, type))
-		goto error_in_scope;
-	
-	if (type != COMP_GENEXP) {
-		ADDOP(c, RETURN_VALUE);
-	}
-
-	co = assemble(c, 1);
-	compiler_exit_scope(c);
-	if (co == NULL)
-		goto error;
-
-	if (!compiler_make_closure(c, co, 0))
-		goto error;
-	Py_DECREF(co);
-
-	VISIT(c, expr, outermost_iter);
-	ADDOP(c, GET_ITER);
-	ADDOP_I(c, CALL_FUNCTION, 1);
-	return 1;
+                       asdl_seq *generators, expr_ty elt, expr_ty val)
+{
+    PyCodeObject *co = NULL;
+    expr_ty outermost_iter;
+
+    outermost_iter = ((comprehension_ty)
+                      asdl_seq_GET(generators, 0))->iter;
+
+    if (!compiler_enter_scope(c, name, (void *)e, e->lineno))
+        goto error;
+
+    if (type != COMP_GENEXP) {
+        int op;
+        switch (type) {
+        case COMP_SETCOMP:
+            op = BUILD_SET;
+            break;
+        case COMP_DICTCOMP:
+            op = BUILD_MAP;
+            break;
+        default:
+            PyErr_Format(PyExc_SystemError,
+                         "unknown comprehension type %d", type);
+            goto error_in_scope;
+        }
+
+        ADDOP_I(c, op, 0);
+    }
+
+    if (!compiler_comprehension_generator(c, generators, 0, elt,
+                                          val, type))
+        goto error_in_scope;
+
+    if (type != COMP_GENEXP) {
+        ADDOP(c, RETURN_VALUE);
+    }
+
+    co = assemble(c, 1);
+    compiler_exit_scope(c);
+    if (co == NULL)
+        goto error;
+
+    if (!compiler_make_closure(c, co, 0))
+        goto error;
+    Py_DECREF(co);
+
+    VISIT(c, expr, outermost_iter);
+    ADDOP(c, GET_ITER);
+    ADDOP_I(c, CALL_FUNCTION, 1);
+    return 1;
 error_in_scope:
-	compiler_exit_scope(c);
+    compiler_exit_scope(c);
 error:
-	Py_XDECREF(co);
-	return 0;
+    Py_XDECREF(co);
+    return 0;
 }
 
 static int
 compiler_genexp(struct compiler *c, expr_ty e)
 {
-	static identifier name;
-	if (!name) {
-		name = PyString_FromString("<genexpr>");
-		if (!name)
-			return 0;
-	}
-	assert(e->kind == GeneratorExp_kind);
-	return compiler_comprehension(c, e, COMP_GENEXP, name,
-				      e->v.GeneratorExp.generators,
-				      e->v.GeneratorExp.elt, NULL);
+    static identifier name;
+    if (!name) {
+        name = PyString_FromString("<genexpr>");
+        if (!name)
+            return 0;
+    }
+    assert(e->kind == GeneratorExp_kind);
+    return compiler_comprehension(c, e, COMP_GENEXP, name,
+                                  e->v.GeneratorExp.generators,
+                                  e->v.GeneratorExp.elt, NULL);
 }
 
 static int
 compiler_setcomp(struct compiler *c, expr_ty e)
 {
-	static identifier name;
-	if (!name) {
-		name = PyString_FromString("<setcomp>");
-		if (!name)
-			return 0;
-	}
-	assert(e->kind == SetComp_kind);
-	return compiler_comprehension(c, e, COMP_SETCOMP, name,
-				      e->v.SetComp.generators,
-				      e->v.SetComp.elt, NULL);
+    static identifier name;
+    if (!name) {
+        name = PyString_FromString("<setcomp>");
+        if (!name)
+            return 0;
+    }
+    assert(e->kind == SetComp_kind);
+    return compiler_comprehension(c, e, COMP_SETCOMP, name,
+                                  e->v.SetComp.generators,
+                                  e->v.SetComp.elt, NULL);
 }
 
 static int
 compiler_dictcomp(struct compiler *c, expr_ty e)
 {
-	static identifier name;
-	if (!name) {
-		name = PyString_FromString("<dictcomp>");
-		if (!name)
-			return 0;
-	}
-	assert(e->kind == DictComp_kind);
-	return compiler_comprehension(c, e, COMP_DICTCOMP, name,
-				      e->v.DictComp.generators,
-				      e->v.DictComp.key, e->v.DictComp.value);
+    static identifier name;
+    if (!name) {
+        name = PyString_FromString("<dictcomp>");
+        if (!name)
+            return 0;
+    }
+    assert(e->kind == DictComp_kind);
+    return compiler_comprehension(c, e, COMP_DICTCOMP, name,
+                                  e->v.DictComp.generators,
+                                  e->v.DictComp.key, e->v.DictComp.value);
 }
 
 static int
 compiler_visit_keyword(struct compiler *c, keyword_ty k)
 {
-	ADDOP_O(c, LOAD_CONST, k->arg, consts);
-	VISIT(c, expr, k->value);
-	return 1;
+    ADDOP_O(c, LOAD_CONST, k->arg, consts);
+    VISIT(c, expr, k->value);
+    return 1;
 }
 
-/* Test whether expression is constant.	 For constants, report
+/* Test whether expression is constant.  For constants, report
    whether they are true or false.
 
    Return values: 1 for true, 0 for false, -1 for non-constant.
@@ -2876,33 +2876,33 @@ compiler_visit_keyword(struct compiler *c, keyword_ty k)
 static int
 expr_constant(expr_ty e)
 {
-	switch (e->kind) {
-	case Num_kind:
-		return PyObject_IsTrue(e->v.Num.n);
-	case Str_kind:
-		return PyObject_IsTrue(e->v.Str.s);
-	case Name_kind:
-		/* __debug__ is not assignable, so we can optimize
-		 * it away in if and while statements */
-		if (strcmp(PyString_AS_STRING(e->v.Name.id),
-			   "__debug__") == 0)
-			   return ! Py_OptimizeFlag;
-		/* fall through */
-	default:
-		return -1;
-	}
+    switch (e->kind) {
+    case Num_kind:
+        return PyObject_IsTrue(e->v.Num.n);
+    case Str_kind:
+        return PyObject_IsTrue(e->v.Str.s);
+    case Name_kind:
+        /* __debug__ is not assignable, so we can optimize
+         * it away in if and while statements */
+        if (strcmp(PyString_AS_STRING(e->v.Name.id),
+                   "__debug__") == 0)
+                   return ! Py_OptimizeFlag;
+        /* fall through */
+    default:
+        return -1;
+    }
 }
 
 /*
    Implements the with statement from PEP 343.
 
-   The semantics outlined in that PEP are as follows:  
+   The semantics outlined in that PEP are as follows:
 
    with EXPR as VAR:
        BLOCK
-  
+
    It is implemented roughly as:
-  
+
    context = EXPR
    exit = context.__exit__  # not calling it
    value = context.__enter__()
@@ -2911,9 +2911,9 @@ expr_constant(expr_ty e)
        BLOCK
    finally:
        if an exception was raised:
-	   exc = copy of (exception, instance, traceback)
+       exc = copy of (exception, instance, traceback)
        else:
-	   exc = (None, None, None)
+       exc = (None, None, None)
        exit(*exc)
  */
 static int
@@ -2926,7 +2926,7 @@ compiler_with(struct compiler *c, stmt_ty s)
     block = compiler_new_block(c);
     finally = compiler_new_block(c);
     if (!block || !finally)
-	return 0;
+    return 0;
 
     /* Evaluate EXPR */
     VISIT(c, expr, s->v.With.context_expr);
@@ -2938,15 +2938,15 @@ compiler_with(struct compiler *c, stmt_ty s)
        functions the same as SETUP_FINALLY except that exceptions are
        normalized. */
     if (!compiler_push_fblock(c, FINALLY_TRY, block)) {
-	return 0;
+    return 0;
     }
 
     if (s->v.With.optional_vars) {
-        VISIT(c, expr, s->v.With.optional_vars);
+    VISIT(c, expr, s->v.With.optional_vars);
     }
     else {
-        /* Discard result from context.__enter__() */
-        ADDOP(c, POP_TOP);
+    /* Discard result from context.__enter__() */
+    ADDOP(c, POP_TOP);
     }
 
     /* BLOCK code */
@@ -2959,7 +2959,7 @@ compiler_with(struct compiler *c, stmt_ty s)
     ADDOP_O(c, LOAD_CONST, Py_None, consts);
     compiler_use_next_block(c, finally);
     if (!compiler_push_fblock(c, FINALLY_END, finally))
-	return 0;
+    return 0;
 
     /* Finally block starts; context.__exit__ is on the stack under
        the exception or return information. Just issue our magic
@@ -2975,226 +2975,226 @@ compiler_with(struct compiler *c, stmt_ty s)
 static int
 compiler_visit_expr(struct compiler *c, expr_ty e)
 {
-	int i, n;
-
-	/* If expr e has a different line number than the last expr/stmt,
-	   set a new line number for the next instruction.
-	*/
-	if (e->lineno > c->u->u_lineno) {
-		c->u->u_lineno = e->lineno;
-		c->u->u_lineno_set = false;
-	}
-	switch (e->kind) {
-	case BoolOp_kind:
-		return compiler_boolop(c, e);
-	case BinOp_kind:
-		VISIT(c, expr, e->v.BinOp.left);
-		VISIT(c, expr, e->v.BinOp.right);
-		ADDOP(c, binop(c, e->v.BinOp.op));
-		break;
-	case UnaryOp_kind:
-		VISIT(c, expr, e->v.UnaryOp.operand);
-		ADDOP(c, unaryop(e->v.UnaryOp.op));
-		break;
-	case Lambda_kind:
-		return compiler_lambda(c, e);
-	case IfExp_kind:
-		return compiler_ifexp(c, e);
-	case Dict_kind:
-		n = asdl_seq_LEN(e->v.Dict.values);
-		ADDOP_I(c, BUILD_MAP, (n>0xFFFF ? 0xFFFF : n));
-		for (i = 0; i < n; i++) {
-			VISIT(c, expr, 
-				(expr_ty)asdl_seq_GET(e->v.Dict.values, i));
-			VISIT(c, expr, 
-				(expr_ty)asdl_seq_GET(e->v.Dict.keys, i));
-			ADDOP(c, STORE_MAP);
-		}
-		break;
-	case Set_kind:
-		n = asdl_seq_LEN(e->v.Set.elts);
-		VISIT_SEQ(c, expr, e->v.Set.elts);
-		ADDOP_I(c, BUILD_SET, n);
-		break;
-	case ListComp_kind:
-		return compiler_listcomp(c, e);
-	case SetComp_kind:
-		return compiler_setcomp(c, e);
-	case DictComp_kind:
-		return compiler_dictcomp(c, e);
-	case GeneratorExp_kind:
-		return compiler_genexp(c, e);
-	case Yield_kind:
-		if (c->u->u_ste->ste_type != FunctionBlock)
-			return compiler_error(c, "'yield' outside function");
-		if (e->v.Yield.value) {
-			VISIT(c, expr, e->v.Yield.value);
-		}
-		else {
-			ADDOP_O(c, LOAD_CONST, Py_None, consts);
-		}
-		ADDOP(c, YIELD_VALUE);
-		break;
-	case Compare_kind:
-		return compiler_compare(c, e);
-	case Call_kind:
-		return compiler_call(c, e);
-	case Repr_kind:
-		VISIT(c, expr, e->v.Repr.value);
-		ADDOP(c, UNARY_CONVERT);
-		break;
-	case Num_kind:
-		ADDOP_O(c, LOAD_CONST, e->v.Num.n, consts);
-		break;
-	case Str_kind:
-		ADDOP_O(c, LOAD_CONST, e->v.Str.s, consts);
-		break;
-	/* The following exprs can be assignment targets. */
-	case Attribute_kind:
-		if (e->v.Attribute.ctx != AugStore)
-			VISIT(c, expr, e->v.Attribute.value);
-		switch (e->v.Attribute.ctx) {
-		case AugLoad:
-			ADDOP(c, DUP_TOP);
-			/* Fall through to load */
-		case Load:
-			ADDOP_NAME(c, LOAD_ATTR, e->v.Attribute.attr, names);
-			break;
-		case AugStore:
-			ADDOP(c, ROT_TWO);
-			/* Fall through to save */
-		case Store:
-			ADDOP_NAME(c, STORE_ATTR, e->v.Attribute.attr, names);
-			break;
-		case Del:
-			ADDOP_NAME(c, DELETE_ATTR, e->v.Attribute.attr, names);
-			break;
-		case Param:
-		default:
-			PyErr_SetString(PyExc_SystemError,
-					"param invalid in attribute expression");
-			return 0;
-		}
-		break;
-	case Subscript_kind:
-		switch (e->v.Subscript.ctx) {
-		case AugLoad:
-			VISIT(c, expr, e->v.Subscript.value);
-			VISIT_SLICE(c, e->v.Subscript.slice, AugLoad);
-			break;
-		case Load:
-			VISIT(c, expr, e->v.Subscript.value);
-			VISIT_SLICE(c, e->v.Subscript.slice, Load);
-			break;
-		case AugStore:
-			VISIT_SLICE(c, e->v.Subscript.slice, AugStore);
-			break;
-		case Store:
-			VISIT(c, expr, e->v.Subscript.value);
-			VISIT_SLICE(c, e->v.Subscript.slice, Store);
-			break;
-		case Del:
-			VISIT(c, expr, e->v.Subscript.value);
-			VISIT_SLICE(c, e->v.Subscript.slice, Del);
-			break;
-		case Param:
-		default:
-			PyErr_SetString(PyExc_SystemError,
-				"param invalid in subscript expression");
-			return 0;
-		}
-		break;
-	case Name_kind:
-		return compiler_nameop(c, e->v.Name.id, e->v.Name.ctx);
-	/* child nodes of List and Tuple will have expr_context set */
-	case List_kind:
-		return compiler_list(c, e);
-	case Tuple_kind:
-		return compiler_tuple(c, e);
-	}
-	return 1;
+    int i, n;
+
+    /* If expr e has a different line number than the last expr/stmt,
+       set a new line number for the next instruction.
+    */
+    if (e->lineno > c->u->u_lineno) {
+        c->u->u_lineno = e->lineno;
+        c->u->u_lineno_set = false;
+    }
+    switch (e->kind) {
+    case BoolOp_kind:
+        return compiler_boolop(c, e);
+    case BinOp_kind:
+        VISIT(c, expr, e->v.BinOp.left);
+        VISIT(c, expr, e->v.BinOp.right);
+        ADDOP(c, binop(c, e->v.BinOp.op));
+        break;
+    case UnaryOp_kind:
+        VISIT(c, expr, e->v.UnaryOp.operand);
+        ADDOP(c, unaryop(e->v.UnaryOp.op));
+        break;
+    case Lambda_kind:
+        return compiler_lambda(c, e);
+    case IfExp_kind:
+        return compiler_ifexp(c, e);
+    case Dict_kind:
+        n = asdl_seq_LEN(e->v.Dict.values);
+        ADDOP_I(c, BUILD_MAP, (n>0xFFFF ? 0xFFFF : n));
+        for (i = 0; i < n; i++) {
+            VISIT(c, expr,
+                (expr_ty)asdl_seq_GET(e->v.Dict.values, i));
+            VISIT(c, expr,
+                (expr_ty)asdl_seq_GET(e->v.Dict.keys, i));
+            ADDOP(c, STORE_MAP);
+        }
+        break;
+    case Set_kind:
+        n = asdl_seq_LEN(e->v.Set.elts);
+        VISIT_SEQ(c, expr, e->v.Set.elts);
+        ADDOP_I(c, BUILD_SET, n);
+        break;
+    case ListComp_kind:
+        return compiler_listcomp(c, e);
+    case SetComp_kind:
+        return compiler_setcomp(c, e);
+    case DictComp_kind:
+        return compiler_dictcomp(c, e);
+    case GeneratorExp_kind:
+        return compiler_genexp(c, e);
+    case Yield_kind:
+        if (c->u->u_ste->ste_type != FunctionBlock)
+            return compiler_error(c, "'yield' outside function");
+        if (e->v.Yield.value) {
+            VISIT(c, expr, e->v.Yield.value);
+        }
+        else {
+            ADDOP_O(c, LOAD_CONST, Py_None, consts);
+        }
+        ADDOP(c, YIELD_VALUE);
+        break;
+    case Compare_kind:
+        return compiler_compare(c, e);
+    case Call_kind:
+        return compiler_call(c, e);
+    case Repr_kind:
+        VISIT(c, expr, e->v.Repr.value);
+        ADDOP(c, UNARY_CONVERT);
+        break;
+    case Num_kind:
+        ADDOP_O(c, LOAD_CONST, e->v.Num.n, consts);
+        break;
+    case Str_kind:
+        ADDOP_O(c, LOAD_CONST, e->v.Str.s, consts);
+        break;
+    /* The following exprs can be assignment targets. */
+    case Attribute_kind:
+        if (e->v.Attribute.ctx != AugStore)
+            VISIT(c, expr, e->v.Attribute.value);
+        switch (e->v.Attribute.ctx) {
+        case AugLoad:
+            ADDOP(c, DUP_TOP);
+            /* Fall through to load */
+        case Load:
+            ADDOP_NAME(c, LOAD_ATTR, e->v.Attribute.attr, names);
+            break;
+        case AugStore:
+            ADDOP(c, ROT_TWO);
+            /* Fall through to save */
+        case Store:
+            ADDOP_NAME(c, STORE_ATTR, e->v.Attribute.attr, names);
+            break;
+        case Del:
+            ADDOP_NAME(c, DELETE_ATTR, e->v.Attribute.attr, names);
+            break;
+        case Param:
+        default:
+            PyErr_SetString(PyExc_SystemError,
+                            "param invalid in attribute expression");
+            return 0;
+        }
+        break;
+    case Subscript_kind:
+        switch (e->v.Subscript.ctx) {
+        case AugLoad:
+            VISIT(c, expr, e->v.Subscript.value);
+            VISIT_SLICE(c, e->v.Subscript.slice, AugLoad);
+            break;
+        case Load:
+            VISIT(c, expr, e->v.Subscript.value);
+            VISIT_SLICE(c, e->v.Subscript.slice, Load);
+            break;
+        case AugStore:
+            VISIT_SLICE(c, e->v.Subscript.slice, AugStore);
+            break;
+        case Store:
+            VISIT(c, expr, e->v.Subscript.value);
+            VISIT_SLICE(c, e->v.Subscript.slice, Store);
+            break;
+        case Del:
+            VISIT(c, expr, e->v.Subscript.value);
+            VISIT_SLICE(c, e->v.Subscript.slice, Del);
+            break;
+        case Param:
+        default:
+            PyErr_SetString(PyExc_SystemError,
+                "param invalid in subscript expression");
+            return 0;
+        }
+        break;
+    case Name_kind:
+        return compiler_nameop(c, e->v.Name.id, e->v.Name.ctx);
+    /* child nodes of List and Tuple will have expr_context set */
+    case List_kind:
+        return compiler_list(c, e);
+    case Tuple_kind:
+        return compiler_tuple(c, e);
+    }
+    return 1;
 }
 
 static int
 compiler_augassign(struct compiler *c, stmt_ty s)
 {
-	expr_ty e = s->v.AugAssign.target;
-	expr_ty auge;
-
-	assert(s->kind == AugAssign_kind);
-
-	switch (e->kind) {
-	case Attribute_kind:
-		auge = Attribute(e->v.Attribute.value, e->v.Attribute.attr,
-				 AugLoad, e->lineno, e->col_offset, c->c_arena);
-		if (auge == NULL)
-		    return 0;
-		VISIT(c, expr, auge);
-		VISIT(c, expr, s->v.AugAssign.value);
-		ADDOP(c, inplace_binop(c, s->v.AugAssign.op));
-		auge->v.Attribute.ctx = AugStore;
-		VISIT(c, expr, auge);
-		break;
-	case Subscript_kind:
-		auge = Subscript(e->v.Subscript.value, e->v.Subscript.slice,
-				 AugLoad, e->lineno, e->col_offset, c->c_arena);
-		if (auge == NULL)
-		    return 0;
-		VISIT(c, expr, auge);
-		VISIT(c, expr, s->v.AugAssign.value);
-		ADDOP(c, inplace_binop(c, s->v.AugAssign.op));
-		auge->v.Subscript.ctx = AugStore;
-		VISIT(c, expr, auge);
-		break;
-	case Name_kind:
-		if (!compiler_nameop(c, e->v.Name.id, Load))
-		    return 0;
-		VISIT(c, expr, s->v.AugAssign.value);
-		ADDOP(c, inplace_binop(c, s->v.AugAssign.op));
-		return compiler_nameop(c, e->v.Name.id, Store);
-	default:
-		PyErr_Format(PyExc_SystemError, 
-			"invalid node type (%d) for augmented assignment",
-			e->kind);
-		return 0;
-	}
-	return 1;
+    expr_ty e = s->v.AugAssign.target;
+    expr_ty auge;
+
+    assert(s->kind == AugAssign_kind);
+
+    switch (e->kind) {
+    case Attribute_kind:
+        auge = Attribute(e->v.Attribute.value, e->v.Attribute.attr,
+                         AugLoad, e->lineno, e->col_offset, c->c_arena);
+        if (auge == NULL)
+            return 0;
+        VISIT(c, expr, auge);
+        VISIT(c, expr, s->v.AugAssign.value);
+        ADDOP(c, inplace_binop(c, s->v.AugAssign.op));
+        auge->v.Attribute.ctx = AugStore;
+        VISIT(c, expr, auge);
+        break;
+    case Subscript_kind:
+        auge = Subscript(e->v.Subscript.value, e->v.Subscript.slice,
+                         AugLoad, e->lineno, e->col_offset, c->c_arena);
+        if (auge == NULL)
+            return 0;
+        VISIT(c, expr, auge);
+        VISIT(c, expr, s->v.AugAssign.value);
+        ADDOP(c, inplace_binop(c, s->v.AugAssign.op));
+        auge->v.Subscript.ctx = AugStore;
+        VISIT(c, expr, auge);
+        break;
+    case Name_kind:
+        if (!compiler_nameop(c, e->v.Name.id, Load))
+            return 0;
+        VISIT(c, expr, s->v.AugAssign.value);
+        ADDOP(c, inplace_binop(c, s->v.AugAssign.op));
+        return compiler_nameop(c, e->v.Name.id, Store);
+    default:
+        PyErr_Format(PyExc_SystemError,
+            "invalid node type (%d) for augmented assignment",
+            e->kind);
+        return 0;
+    }
+    return 1;
 }
 
 static int
 compiler_push_fblock(struct compiler *c, enum fblocktype t, basicblock *b)
 {
-	struct fblockinfo *f;
-	if (c->u->u_nfblocks >= CO_MAXBLOCKS) {
-		PyErr_SetString(PyExc_SystemError,
-				"too many statically nested blocks");
-		return 0;
-	}
-	f = &c->u->u_fblock[c->u->u_nfblocks++];
-	f->fb_type = t;
-	f->fb_block = b;
-	return 1;
+    struct fblockinfo *f;
+    if (c->u->u_nfblocks >= CO_MAXBLOCKS) {
+        PyErr_SetString(PyExc_SystemError,
+                        "too many statically nested blocks");
+        return 0;
+    }
+    f = &c->u->u_fblock[c->u->u_nfblocks++];
+    f->fb_type = t;
+    f->fb_block = b;
+    return 1;
 }
 
 static void
 compiler_pop_fblock(struct compiler *c, enum fblocktype t, basicblock *b)
 {
-	struct compiler_unit *u = c->u;
-	assert(u->u_nfblocks > 0);
-	u->u_nfblocks--;
-	assert(u->u_fblock[u->u_nfblocks].fb_type == t);
-	assert(u->u_fblock[u->u_nfblocks].fb_block == b);
+    struct compiler_unit *u = c->u;
+    assert(u->u_nfblocks > 0);
+    u->u_nfblocks--;
+    assert(u->u_fblock[u->u_nfblocks].fb_type == t);
+    assert(u->u_fblock[u->u_nfblocks].fb_block == b);
 }
 
 static int
 compiler_in_loop(struct compiler *c) {
-	int i;
-	struct compiler_unit *u = c->u;
-	for (i = 0; i < u->u_nfblocks; ++i) {
-		if (u->u_fblock[i].fb_type == LOOP)
-			return 1;
-	}
-	return 0;
+    int i;
+    struct compiler_unit *u = c->u;
+    for (i = 0; i < u->u_nfblocks; ++i) {
+        if (u->u_fblock[i].fb_type == LOOP)
+            return 1;
+    }
+    return 0;
 }
 /* Raises a SyntaxError and returns 0.
    If something goes wrong, a different exception may be raised.
@@ -3203,205 +3203,205 @@ compiler_in_loop(struct compiler *c) {
 static int
 compiler_error(struct compiler *c, const char *errstr)
 {
-	PyObject *loc;
-	PyObject *u = NULL, *v = NULL;
-
-	loc = PyErr_ProgramText(c->c_filename, c->u->u_lineno);
-	if (!loc) {
-		Py_INCREF(Py_None);
-		loc = Py_None;
-	}
-	u = Py_BuildValue("(ziOO)", c->c_filename, c->u->u_lineno,
-			  Py_None, loc);
-	if (!u)
-		goto exit;
-	v = Py_BuildValue("(zO)", errstr, u);
-	if (!v)
-		goto exit;
-	PyErr_SetObject(PyExc_SyntaxError, v);
+    PyObject *loc;
+    PyObject *u = NULL, *v = NULL;
+
+    loc = PyErr_ProgramText(c->c_filename, c->u->u_lineno);
+    if (!loc) {
+        Py_INCREF(Py_None);
+        loc = Py_None;
+    }
+    u = Py_BuildValue("(ziOO)", c->c_filename, c->u->u_lineno,
+                      Py_None, loc);
+    if (!u)
+        goto exit;
+    v = Py_BuildValue("(zO)", errstr, u);
+    if (!v)
+        goto exit;
+    PyErr_SetObject(PyExc_SyntaxError, v);
  exit:
-	Py_DECREF(loc);
-	Py_XDECREF(u);
-	Py_XDECREF(v);
-	return 0;
-}
-
-static int
-compiler_handle_subscr(struct compiler *c, const char *kind, 
-		       expr_context_ty ctx) 
-{
-	int op = 0;
-
-	/* XXX this code is duplicated */
-	switch (ctx) {
-		case AugLoad: /* fall through to Load */
-		case Load:    op = BINARY_SUBSCR; break;
-		case AugStore:/* fall through to Store */
-		case Store:   op = STORE_SUBSCR; break;
-		case Del:     op = DELETE_SUBSCR; break;
-		case Param:
-			PyErr_Format(PyExc_SystemError, 
-				     "invalid %s kind %d in subscript\n", 
-				     kind, ctx);
-			return 0;
-	}
-	if (ctx == AugLoad) {
-		ADDOP_I(c, DUP_TOPX, 2);
-	}
-	else if (ctx == AugStore) {
-		ADDOP(c, ROT_THREE);
-	}
-	ADDOP(c, op);
-	return 1;
+    Py_DECREF(loc);
+    Py_XDECREF(u);
+    Py_XDECREF(v);
+    return 0;
+}
+
+static int
+compiler_handle_subscr(struct compiler *c, const char *kind,
+                       expr_context_ty ctx)
+{
+    int op = 0;
+
+    /* XXX this code is duplicated */
+    switch (ctx) {
+        case AugLoad: /* fall through to Load */
+        case Load:    op = BINARY_SUBSCR; break;
+        case AugStore:/* fall through to Store */
+        case Store:   op = STORE_SUBSCR; break;
+        case Del:     op = DELETE_SUBSCR; break;
+        case Param:
+            PyErr_Format(PyExc_SystemError,
+                         "invalid %s kind %d in subscript\n",
+                         kind, ctx);
+            return 0;
+    }
+    if (ctx == AugLoad) {
+        ADDOP_I(c, DUP_TOPX, 2);
+    }
+    else if (ctx == AugStore) {
+        ADDOP(c, ROT_THREE);
+    }
+    ADDOP(c, op);
+    return 1;
 }
 
 static int
 compiler_slice(struct compiler *c, slice_ty s, expr_context_ty ctx)
 {
-	int n = 2;
-	assert(s->kind == Slice_kind);
-
-	/* only handles the cases where BUILD_SLICE is emitted */
-	if (s->v.Slice.lower) {
-		VISIT(c, expr, s->v.Slice.lower);
-	}
-	else {
-		ADDOP_O(c, LOAD_CONST, Py_None, consts);
-	}
-		
-	if (s->v.Slice.upper) {
-		VISIT(c, expr, s->v.Slice.upper);
-	}
-	else {
-		ADDOP_O(c, LOAD_CONST, Py_None, consts);
-	}
-
-	if (s->v.Slice.step) {
-		n++;
-		VISIT(c, expr, s->v.Slice.step);
-	}
-	ADDOP_I(c, BUILD_SLICE, n);
-	return 1;
+    int n = 2;
+    assert(s->kind == Slice_kind);
+
+    /* only handles the cases where BUILD_SLICE is emitted */
+    if (s->v.Slice.lower) {
+        VISIT(c, expr, s->v.Slice.lower);
+    }
+    else {
+        ADDOP_O(c, LOAD_CONST, Py_None, consts);
+    }
+
+    if (s->v.Slice.upper) {
+        VISIT(c, expr, s->v.Slice.upper);
+    }
+    else {
+        ADDOP_O(c, LOAD_CONST, Py_None, consts);
+    }
+
+    if (s->v.Slice.step) {
+        n++;
+        VISIT(c, expr, s->v.Slice.step);
+    }
+    ADDOP_I(c, BUILD_SLICE, n);
+    return 1;
 }
 
 static int
 compiler_simple_slice(struct compiler *c, slice_ty s, expr_context_ty ctx)
 {
-	int op = 0, slice_offset = 0, stack_count = 0;
-
-	assert(s->v.Slice.step == NULL);
-	if (s->v.Slice.lower) {
-		slice_offset++;
-		stack_count++;
-		if (ctx != AugStore) 
-			VISIT(c, expr, s->v.Slice.lower);
-	}
-	if (s->v.Slice.upper) {
-		slice_offset += 2;
-		stack_count++;
-		if (ctx != AugStore) 
-			VISIT(c, expr, s->v.Slice.upper);
-	}
-
-	if (ctx == AugLoad) {
-		switch (stack_count) {
-		case 0: ADDOP(c, DUP_TOP); break;
-		case 1: ADDOP_I(c, DUP_TOPX, 2); break;
-		case 2: ADDOP_I(c, DUP_TOPX, 3); break;
-		}
-	}
-	else if (ctx == AugStore) {
-		switch (stack_count) {
-		case 0: ADDOP(c, ROT_TWO); break;
-		case 1: ADDOP(c, ROT_THREE); break;
-		case 2: ADDOP(c, ROT_FOUR); break;
-		}
-	}
-
-	switch (ctx) {
-	case AugLoad: /* fall through to Load */
-	case Load: op = SLICE; break;
-	case AugStore:/* fall through to Store */
-	case Store: op = STORE_SLICE; break;
-	case Del: op = DELETE_SLICE; break;
-	case Param:
-	default:
-		PyErr_SetString(PyExc_SystemError,
-				"param invalid in simple slice");
-		return 0;
-	}
-
-	ADDOP(c, op + slice_offset);
-	return 1;
-}
-
-static int
-compiler_visit_nested_slice(struct compiler *c, slice_ty s, 
-			    expr_context_ty ctx)
-{
-	switch (s->kind) {
-	case Ellipsis_kind:
-		ADDOP_O(c, LOAD_CONST, Py_Ellipsis, consts);
-		break;
-	case Slice_kind:
-		return compiler_slice(c, s, ctx);
-	case Index_kind:
-		VISIT(c, expr, s->v.Index.value);
-		break;
-	case ExtSlice_kind:
-	default:
-		PyErr_SetString(PyExc_SystemError,
-				"extended slice invalid in nested slice");
-		return 0;
-	}
-	return 1;
+    int op = 0, slice_offset = 0, stack_count = 0;
+
+    assert(s->v.Slice.step == NULL);
+    if (s->v.Slice.lower) {
+        slice_offset++;
+        stack_count++;
+        if (ctx != AugStore)
+            VISIT(c, expr, s->v.Slice.lower);
+    }
+    if (s->v.Slice.upper) {
+        slice_offset += 2;
+        stack_count++;
+        if (ctx != AugStore)
+            VISIT(c, expr, s->v.Slice.upper);
+    }
+
+    if (ctx == AugLoad) {
+        switch (stack_count) {
+        case 0: ADDOP(c, DUP_TOP); break;
+        case 1: ADDOP_I(c, DUP_TOPX, 2); break;
+        case 2: ADDOP_I(c, DUP_TOPX, 3); break;
+        }
+    }
+    else if (ctx == AugStore) {
+        switch (stack_count) {
+        case 0: ADDOP(c, ROT_TWO); break;
+        case 1: ADDOP(c, ROT_THREE); break;
+        case 2: ADDOP(c, ROT_FOUR); break;
+        }
+    }
+
+    switch (ctx) {
+    case AugLoad: /* fall through to Load */
+    case Load: op = SLICE; break;
+    case AugStore:/* fall through to Store */
+    case Store: op = STORE_SLICE; break;
+    case Del: op = DELETE_SLICE; break;
+    case Param:
+    default:
+        PyErr_SetString(PyExc_SystemError,
+                        "param invalid in simple slice");
+        return 0;
+    }
+
+    ADDOP(c, op + slice_offset);
+    return 1;
+}
+
+static int
+compiler_visit_nested_slice(struct compiler *c, slice_ty s,
+                            expr_context_ty ctx)
+{
+    switch (s->kind) {
+    case Ellipsis_kind:
+        ADDOP_O(c, LOAD_CONST, Py_Ellipsis, consts);
+        break;
+    case Slice_kind:
+        return compiler_slice(c, s, ctx);
+    case Index_kind:
+        VISIT(c, expr, s->v.Index.value);
+        break;
+    case ExtSlice_kind:
+    default:
+        PyErr_SetString(PyExc_SystemError,
+                        "extended slice invalid in nested slice");
+        return 0;
+    }
+    return 1;
 }
 
 static int
 compiler_visit_slice(struct compiler *c, slice_ty s, expr_context_ty ctx)
 {
-	char * kindname = NULL;
-	switch (s->kind) {
-	case Index_kind:
-		kindname = "index";
-		if (ctx != AugStore) {
-			VISIT(c, expr, s->v.Index.value);
-		}
-		break;
-	case Ellipsis_kind:
-		kindname = "ellipsis";
-		if (ctx != AugStore) {
-			ADDOP_O(c, LOAD_CONST, Py_Ellipsis, consts);
-		}
-		break;
-	case Slice_kind:
-		kindname = "slice";
-		if (!s->v.Slice.step) 
-			return compiler_simple_slice(c, s, ctx);
-		if (ctx != AugStore) {
-			if (!compiler_slice(c, s, ctx))
-				return 0;
-		}
-		break;
-	case ExtSlice_kind:
-		kindname = "extended slice";
-		if (ctx != AugStore) {
-			int i, n = asdl_seq_LEN(s->v.ExtSlice.dims);
-			for (i = 0; i < n; i++) {
-				slice_ty sub = (slice_ty)asdl_seq_GET(
-					s->v.ExtSlice.dims, i);
-				if (!compiler_visit_nested_slice(c, sub, ctx))
-					return 0;
-			}
-			ADDOP_I(c, BUILD_TUPLE, n);
-		}
-		break;
-	default:
-		PyErr_Format(PyExc_SystemError,
-			     "invalid subscript kind %d", s->kind);
-		return 0;
-	}
-	return compiler_handle_subscr(c, kindname, ctx);
+    char * kindname = NULL;
+    switch (s->kind) {
+    case Index_kind:
+        kindname = "index";
+        if (ctx != AugStore) {
+            VISIT(c, expr, s->v.Index.value);
+        }
+        break;
+    case Ellipsis_kind:
+        kindname = "ellipsis";
+        if (ctx != AugStore) {
+            ADDOP_O(c, LOAD_CONST, Py_Ellipsis, consts);
+        }
+        break;
+    case Slice_kind:
+        kindname = "slice";
+        if (!s->v.Slice.step)
+            return compiler_simple_slice(c, s, ctx);
+        if (ctx != AugStore) {
+            if (!compiler_slice(c, s, ctx))
+                return 0;
+        }
+        break;
+    case ExtSlice_kind:
+        kindname = "extended slice";
+        if (ctx != AugStore) {
+            int i, n = asdl_seq_LEN(s->v.ExtSlice.dims);
+            for (i = 0; i < n; i++) {
+                slice_ty sub = (slice_ty)asdl_seq_GET(
+                    s->v.ExtSlice.dims, i);
+                if (!compiler_visit_nested_slice(c, sub, ctx))
+                    return 0;
+            }
+            ADDOP_I(c, BUILD_TUPLE, n);
+        }
+        break;
+    default:
+        PyErr_Format(PyExc_SystemError,
+                     "invalid subscript kind %d", s->kind);
+        return 0;
+    }
+    return compiler_handle_subscr(c, kindname, ctx);
 }
 
 
@@ -3414,73 +3414,73 @@ compiler_visit_slice(struct compiler *c, slice_ty s, expr_context_ty ctx)
 */
 
 struct assembler {
-	PyObject *a_bytecode;  /* string containing bytecode */
-	int a_offset;	       /* offset into bytecode */
-	int a_nblocks;	       /* number of reachable blocks */
-	basicblock **a_postorder; /* list of blocks in dfs postorder */
-	PyObject *a_lnotab;    /* string containing lnotab */
-	int a_lnotab_off;      /* offset into lnotab */
-	int a_lineno;	       /* last lineno of emitted instruction */
-	int a_lineno_off;      /* bytecode offset of last lineno */
+    PyObject *a_bytecode;  /* string containing bytecode */
+    int a_offset;              /* offset into bytecode */
+    int a_nblocks;             /* number of reachable blocks */
+    basicblock **a_postorder; /* list of blocks in dfs postorder */
+    PyObject *a_lnotab;    /* string containing lnotab */
+    int a_lnotab_off;      /* offset into lnotab */
+    int a_lineno;              /* last lineno of emitted instruction */
+    int a_lineno_off;      /* bytecode offset of last lineno */
 };
 
 static void
 dfs(struct compiler *c, basicblock *b, struct assembler *a)
 {
-	int i;
-	struct instr *instr = NULL;
-
-	if (b->b_seen)
-		return;
-	b->b_seen = 1;
-	if (b->b_next != NULL)
-		dfs(c, b->b_next, a);
-	for (i = 0; i < b->b_iused; i++) {
-		instr = &b->b_instr[i];
-		if (instr->i_jrel || instr->i_jabs)
-			dfs(c, instr->i_target, a);
-	}
-	a->a_postorder[a->a_nblocks++] = b;
+    int i;
+    struct instr *instr = NULL;
+
+    if (b->b_seen)
+        return;
+    b->b_seen = 1;
+    if (b->b_next != NULL)
+        dfs(c, b->b_next, a);
+    for (i = 0; i < b->b_iused; i++) {
+        instr = &b->b_instr[i];
+        if (instr->i_jrel || instr->i_jabs)
+            dfs(c, instr->i_target, a);
+    }
+    a->a_postorder[a->a_nblocks++] = b;
 }
 
 static int
 stackdepth_walk(struct compiler *c, basicblock *b, int depth, int maxdepth)
 {
-	int i, target_depth;
-	struct instr *instr;
-	if (b->b_seen || b->b_startdepth >= depth)
-		return maxdepth;
-	b->b_seen = 1;
-	b->b_startdepth = depth;
-	for (i = 0; i < b->b_iused; i++) {
-		instr = &b->b_instr[i];
-		depth += opcode_stack_effect(instr->i_opcode, instr->i_oparg);
-		if (depth > maxdepth)
-			maxdepth = depth;
-		assert(depth >= 0); /* invalid code or bug in stackdepth() */
-		if (instr->i_jrel || instr->i_jabs) {
-			target_depth = depth;
-			if (instr->i_opcode == FOR_ITER) {
-				target_depth = depth-2;
-			} else if (instr->i_opcode == SETUP_FINALLY ||
-				   instr->i_opcode == SETUP_EXCEPT) {
-				target_depth = depth+3;
-				if (target_depth > maxdepth)
-					maxdepth = target_depth;
-			}
-			maxdepth = stackdepth_walk(c, instr->i_target,
-						   target_depth, maxdepth);
-			if (instr->i_opcode == JUMP_ABSOLUTE ||
-			    instr->i_opcode == JUMP_FORWARD) {
-				goto out; /* remaining code is dead */
-			}
-		}
-	}
-	if (b->b_next)
-		maxdepth = stackdepth_walk(c, b->b_next, depth, maxdepth);
+    int i, target_depth;
+    struct instr *instr;
+    if (b->b_seen || b->b_startdepth >= depth)
+        return maxdepth;
+    b->b_seen = 1;
+    b->b_startdepth = depth;
+    for (i = 0; i < b->b_iused; i++) {
+        instr = &b->b_instr[i];
+        depth += opcode_stack_effect(instr->i_opcode, instr->i_oparg);
+        if (depth > maxdepth)
+            maxdepth = depth;
+        assert(depth >= 0); /* invalid code or bug in stackdepth() */
+        if (instr->i_jrel || instr->i_jabs) {
+            target_depth = depth;
+            if (instr->i_opcode == FOR_ITER) {
+                target_depth = depth-2;
+            } else if (instr->i_opcode == SETUP_FINALLY ||
+                       instr->i_opcode == SETUP_EXCEPT) {
+                target_depth = depth+3;
+                if (target_depth > maxdepth)
+                    maxdepth = target_depth;
+            }
+            maxdepth = stackdepth_walk(c, instr->i_target,
+                                       target_depth, maxdepth);
+            if (instr->i_opcode == JUMP_ABSOLUTE ||
+                instr->i_opcode == JUMP_FORWARD) {
+                goto out; /* remaining code is dead */
+            }
+        }
+    }
+    if (b->b_next)
+        maxdepth = stackdepth_walk(c, b->b_next, depth, maxdepth);
 out:
-	b->b_seen = 0;
-	return maxdepth;
+    b->b_seen = 0;
+    return maxdepth;
 }
 
 /* Find the flow path that needs the largest stack.  We assume that
@@ -3489,49 +3489,49 @@ out:
 static int
 stackdepth(struct compiler *c)
 {
-	basicblock *b, *entryblock;
-	entryblock = NULL;
-	for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
-		b->b_seen = 0;
-		b->b_startdepth = INT_MIN;
-		entryblock = b;
-	}
-	if (!entryblock)
-		return 0;
-	return stackdepth_walk(c, entryblock, 0, 0);
+    basicblock *b, *entryblock;
+    entryblock = NULL;
+    for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
+        b->b_seen = 0;
+        b->b_startdepth = INT_MIN;
+        entryblock = b;
+    }
+    if (!entryblock)
+        return 0;
+    return stackdepth_walk(c, entryblock, 0, 0);
 }
 
 static int
 assemble_init(struct assembler *a, int nblocks, int firstlineno)
 {
-	memset(a, 0, sizeof(struct assembler));
-	a->a_lineno = firstlineno;
-	a->a_bytecode = PyString_FromStringAndSize(NULL, DEFAULT_CODE_SIZE);
-	if (!a->a_bytecode)
-		return 0;
-	a->a_lnotab = PyString_FromStringAndSize(NULL, DEFAULT_LNOTAB_SIZE);
-	if (!a->a_lnotab)
-		return 0;
-	if (nblocks > PY_SIZE_MAX / sizeof(basicblock *)) {
-		PyErr_NoMemory();
-		return 0;
-	}
-	a->a_postorder = (basicblock **)PyObject_Malloc(
-					    sizeof(basicblock *) * nblocks);
-	if (!a->a_postorder) {
-		PyErr_NoMemory();
-		return 0;
-	}
-	return 1;
+    memset(a, 0, sizeof(struct assembler));
+    a->a_lineno = firstlineno;
+    a->a_bytecode = PyString_FromStringAndSize(NULL, DEFAULT_CODE_SIZE);
+    if (!a->a_bytecode)
+        return 0;
+    a->a_lnotab = PyString_FromStringAndSize(NULL, DEFAULT_LNOTAB_SIZE);
+    if (!a->a_lnotab)
+        return 0;
+    if (nblocks > PY_SIZE_MAX / sizeof(basicblock *)) {
+        PyErr_NoMemory();
+        return 0;
+    }
+    a->a_postorder = (basicblock **)PyObject_Malloc(
+                                        sizeof(basicblock *) * nblocks);
+    if (!a->a_postorder) {
+        PyErr_NoMemory();
+        return 0;
+    }
+    return 1;
 }
 
 static void
 assemble_free(struct assembler *a)
 {
-	Py_XDECREF(a->a_bytecode);
-	Py_XDECREF(a->a_lnotab);
-	if (a->a_postorder)
-		PyObject_Free(a->a_postorder);
+    Py_XDECREF(a->a_bytecode);
+    Py_XDECREF(a->a_lnotab);
+    if (a->a_postorder)
+        PyObject_Free(a->a_postorder);
 }
 
 /* Return the size of a basic block in bytes. */
@@ -3539,22 +3539,22 @@ assemble_free(struct assembler *a)
 static int
 instrsize(struct instr *instr)
 {
-	if (!instr->i_hasarg)
-		return 1;	/* 1 byte for the opcode*/
-	if (instr->i_oparg > 0xffff)
-		return 6;	/* 1 (opcode) + 1 (EXTENDED_ARG opcode) + 2 (oparg) + 2(oparg extended) */
-	return 3; 		/* 1 (opcode) + 2 (oparg) */
+    if (!instr->i_hasarg)
+        return 1;               /* 1 byte for the opcode*/
+    if (instr->i_oparg > 0xffff)
+        return 6;               /* 1 (opcode) + 1 (EXTENDED_ARG opcode) + 2 (oparg) + 2(oparg extended) */
+    return 3;                   /* 1 (opcode) + 2 (oparg) */
 }
 
 static int
 blocksize(basicblock *b)
 {
-	int i;
-	int size = 0;
+    int i;
+    int size = 0;
 
-	for (i = 0; i < b->b_iused; i++)
-		size += instrsize(&b->b_instr[i]);
-	return size;
+    for (i = 0; i < b->b_iused; i++)
+        size += instrsize(&b->b_instr[i]);
+    return size;
 }
 
 /* Appends a pair to the end of the line number table, a_lnotab, representing
@@ -3564,94 +3564,94 @@ blocksize(basicblock *b)
 static int
 assemble_lnotab(struct assembler *a, struct instr *i)
 {
-	int d_bytecode, d_lineno;
-	int len;
-	unsigned char *lnotab;
-
-	d_bytecode = a->a_offset - a->a_lineno_off;
-	d_lineno = i->i_lineno - a->a_lineno;
-
-	assert(d_bytecode >= 0);
-	assert(d_lineno >= 0);
-
-	if(d_bytecode == 0 && d_lineno == 0)
-		return 1;
-
-	if (d_bytecode > 255) {
-		int j, nbytes, ncodes = d_bytecode / 255;
-		nbytes = a->a_lnotab_off + 2 * ncodes;
-		len = PyString_GET_SIZE(a->a_lnotab);
-		if (nbytes >= len) {
-			if ((len <= INT_MAX / 2) && (len * 2 < nbytes))
-				len = nbytes;
-			else if (len <= INT_MAX / 2)
-				len *= 2;
-			else {
-				PyErr_NoMemory();
-				return 0;
-			}
-			if (_PyString_Resize(&a->a_lnotab, len) < 0)
-				return 0;
-		}
-		lnotab = (unsigned char *)
-			   PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
-		for (j = 0; j < ncodes; j++) {
-			*lnotab++ = 255;
-			*lnotab++ = 0;
-		}
-		d_bytecode -= ncodes * 255;
-		a->a_lnotab_off += ncodes * 2;
-	}
-	assert(d_bytecode <= 255);
-	if (d_lineno > 255) {
-		int j, nbytes, ncodes = d_lineno / 255;
-		nbytes = a->a_lnotab_off + 2 * ncodes;
-		len = PyString_GET_SIZE(a->a_lnotab);
-		if (nbytes >= len) {
-			if ((len <= INT_MAX / 2) && len * 2 < nbytes)
-				len = nbytes;
-			else if (len <= INT_MAX / 2)
-				len *= 2;
-			else {
-				PyErr_NoMemory();
-				return 0;
-			}
-			if (_PyString_Resize(&a->a_lnotab, len) < 0)
-				return 0;
-		}
-		lnotab = (unsigned char *)
-			   PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
-		*lnotab++ = d_bytecode;
-		*lnotab++ = 255;
-		d_bytecode = 0;
-		for (j = 1; j < ncodes; j++) {
-			*lnotab++ = 0;
-			*lnotab++ = 255;
-		}
-		d_lineno -= ncodes * 255;
-		a->a_lnotab_off += ncodes * 2;
-	}
-
-	len = PyString_GET_SIZE(a->a_lnotab);
-	if (a->a_lnotab_off + 2 >= len) {
-		if (_PyString_Resize(&a->a_lnotab, len * 2) < 0)
-			return 0;
-	}
-	lnotab = (unsigned char *)
-			PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
-
-	a->a_lnotab_off += 2;
-	if (d_bytecode) {
-		*lnotab++ = d_bytecode;
-		*lnotab++ = d_lineno;
-	}
-	else {	/* First line of a block; def stmt, etc. */
-		*lnotab++ = 0;
-		*lnotab++ = d_lineno;
-	}
-	a->a_lineno = i->i_lineno;
-	a->a_lineno_off = a->a_offset;
-	return 1;
+    int d_bytecode, d_lineno;
+    int len;
+    unsigned char *lnotab;
+
+    d_bytecode = a->a_offset - a->a_lineno_off;
+    d_lineno = i->i_lineno - a->a_lineno;
+
+    assert(d_bytecode >= 0);
+    assert(d_lineno >= 0);
+
+    if(d_bytecode == 0 && d_lineno == 0)
+        return 1;
+
+    if (d_bytecode > 255) {
+        int j, nbytes, ncodes = d_bytecode / 255;
+        nbytes = a->a_lnotab_off + 2 * ncodes;
+        len = PyString_GET_SIZE(a->a_lnotab);
+        if (nbytes >= len) {
+            if ((len <= INT_MAX / 2) && (len * 2 < nbytes))
+                len = nbytes;
+            else if (len <= INT_MAX / 2)
+                len *= 2;
+            else {
+                PyErr_NoMemory();
+                return 0;
+            }
+            if (_PyString_Resize(&a->a_lnotab, len) < 0)
+                return 0;
+        }
+        lnotab = (unsigned char *)
+                   PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
+        for (j = 0; j < ncodes; j++) {
+            *lnotab++ = 255;
+            *lnotab++ = 0;
+        }
+        d_bytecode -= ncodes * 255;
+        a->a_lnotab_off += ncodes * 2;
+    }
+    assert(d_bytecode <= 255);
+    if (d_lineno > 255) {
+        int j, nbytes, ncodes = d_lineno / 255;
+        nbytes = a->a_lnotab_off + 2 * ncodes;
+        len = PyString_GET_SIZE(a->a_lnotab);
+        if (nbytes >= len) {
+            if ((len <= INT_MAX / 2) && len * 2 < nbytes)
+                len = nbytes;
+            else if (len <= INT_MAX / 2)
+                len *= 2;
+            else {
+                PyErr_NoMemory();
+                return 0;
+            }
+            if (_PyString_Resize(&a->a_lnotab, len) < 0)
+                return 0;
+        }
+        lnotab = (unsigned char *)
+                   PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
+        *lnotab++ = d_bytecode;
+        *lnotab++ = 255;
+        d_bytecode = 0;
+        for (j = 1; j < ncodes; j++) {
+            *lnotab++ = 0;
+            *lnotab++ = 255;
+        }
+        d_lineno -= ncodes * 255;
+        a->a_lnotab_off += ncodes * 2;
+    }
+
+    len = PyString_GET_SIZE(a->a_lnotab);
+    if (a->a_lnotab_off + 2 >= len) {
+        if (_PyString_Resize(&a->a_lnotab, len * 2) < 0)
+            return 0;
+    }
+    lnotab = (unsigned char *)
+                    PyString_AS_STRING(a->a_lnotab) + a->a_lnotab_off;
+
+    a->a_lnotab_off += 2;
+    if (d_bytecode) {
+        *lnotab++ = d_bytecode;
+        *lnotab++ = d_lineno;
+    }
+    else {      /* First line of a block; def stmt, etc. */
+        *lnotab++ = 0;
+        *lnotab++ = d_lineno;
+    }
+    a->a_lineno = i->i_lineno;
+    a->a_lineno_off = a->a_offset;
+    return 1;
 }
 
 /* assemble_emit()
@@ -3662,226 +3662,226 @@ assemble_lnotab(struct assembler *a, struct instr *i)
 static int
 assemble_emit(struct assembler *a, struct instr *i)
 {
-	int size, arg = 0, ext = 0;
-	Py_ssize_t len = PyString_GET_SIZE(a->a_bytecode);
-	char *code;
-
-	size = instrsize(i);
-	if (i->i_hasarg) {
-		arg = i->i_oparg;
-		ext = arg >> 16;
-	}
-	if (i->i_lineno && !assemble_lnotab(a, i))
-		return 0;
-	if (a->a_offset + size >= len) {
-		if (len > PY_SSIZE_T_MAX / 2)
-			return 0;
-		if (_PyString_Resize(&a->a_bytecode, len * 2) < 0)
-		    return 0;
-	}
-	code = PyString_AS_STRING(a->a_bytecode) + a->a_offset;
-	a->a_offset += size;
-	if (size == 6) {
-		assert(i->i_hasarg);
-		*code++ = (char)EXTENDED_ARG;
-		*code++ = ext & 0xff;
-		*code++ = ext >> 8;
-		arg &= 0xffff;
-	}
-	*code++ = i->i_opcode;
-	if (i->i_hasarg) {
-		assert(size == 3 || size == 6);
-		*code++ = arg & 0xff;
-		*code++ = arg >> 8;
-	}
-	return 1;
+    int size, arg = 0, ext = 0;
+    Py_ssize_t len = PyString_GET_SIZE(a->a_bytecode);
+    char *code;
+
+    size = instrsize(i);
+    if (i->i_hasarg) {
+        arg = i->i_oparg;
+        ext = arg >> 16;
+    }
+    if (i->i_lineno && !assemble_lnotab(a, i))
+        return 0;
+    if (a->a_offset + size >= len) {
+        if (len > PY_SSIZE_T_MAX / 2)
+            return 0;
+        if (_PyString_Resize(&a->a_bytecode, len * 2) < 0)
+            return 0;
+    }
+    code = PyString_AS_STRING(a->a_bytecode) + a->a_offset;
+    a->a_offset += size;
+    if (size == 6) {
+        assert(i->i_hasarg);
+        *code++ = (char)EXTENDED_ARG;
+        *code++ = ext & 0xff;
+        *code++ = ext >> 8;
+        arg &= 0xffff;
+    }
+    *code++ = i->i_opcode;
+    if (i->i_hasarg) {
+        assert(size == 3 || size == 6);
+        *code++ = arg & 0xff;
+        *code++ = arg >> 8;
+    }
+    return 1;
 }
 
 static void
 assemble_jump_offsets(struct assembler *a, struct compiler *c)
 {
-	basicblock *b;
-	int bsize, totsize, extended_arg_count = 0, last_extended_arg_count;
-	int i;
-
-	/* Compute the size of each block and fixup jump args.
-	   Replace block pointer with position in bytecode. */
-	do {
-		totsize = 0;
-		for (i = a->a_nblocks - 1; i >= 0; i--) {
-			b = a->a_postorder[i];
-			bsize = blocksize(b);
-			b->b_offset = totsize;
-			totsize += bsize;
-		}
-		last_extended_arg_count = extended_arg_count;
-		extended_arg_count = 0;
-		for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
-			bsize = b->b_offset;
-			for (i = 0; i < b->b_iused; i++) {
-				struct instr *instr = &b->b_instr[i];
-				/* Relative jumps are computed relative to
-				   the instruction pointer after fetching
-				   the jump instruction.
-				*/
-				bsize += instrsize(instr);
-				if (instr->i_jabs)
-					instr->i_oparg = instr->i_target->b_offset;
-				else if (instr->i_jrel) {
-					int delta = instr->i_target->b_offset - bsize;
-					instr->i_oparg = delta;
-				}
-				else
-					continue;
-				if (instr->i_oparg > 0xffff)
-					extended_arg_count++;
-			}
-		}
-
-	/* XXX: This is an awful hack that could hurt performance, but
-		on the bright side it should work until we come up
-		with a better solution.
-
-		The issue is that in the first loop blocksize() is called
-		which calls instrsize() which requires i_oparg be set
-		appropriately.	There is a bootstrap problem because
-		i_oparg is calculated in the second loop above.
-
-		So we loop until we stop seeing new EXTENDED_ARGs.
-		The only EXTENDED_ARGs that could be popping up are
-		ones in jump instructions.  So this should converge
-		fairly quickly.
-	*/
-	} while (last_extended_arg_count != extended_arg_count);
+    basicblock *b;
+    int bsize, totsize, extended_arg_count = 0, last_extended_arg_count;
+    int i;
+
+    /* Compute the size of each block and fixup jump args.
+       Replace block pointer with position in bytecode. */
+    do {
+        totsize = 0;
+        for (i = a->a_nblocks - 1; i >= 0; i--) {
+            b = a->a_postorder[i];
+            bsize = blocksize(b);
+            b->b_offset = totsize;
+            totsize += bsize;
+        }
+        last_extended_arg_count = extended_arg_count;
+        extended_arg_count = 0;
+        for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
+            bsize = b->b_offset;
+            for (i = 0; i < b->b_iused; i++) {
+                struct instr *instr = &b->b_instr[i];
+                /* Relative jumps are computed relative to
+                   the instruction pointer after fetching
+                   the jump instruction.
+                */
+                bsize += instrsize(instr);
+                if (instr->i_jabs)
+                    instr->i_oparg = instr->i_target->b_offset;
+                else if (instr->i_jrel) {
+                    int delta = instr->i_target->b_offset - bsize;
+                    instr->i_oparg = delta;
+                }
+                else
+                    continue;
+                if (instr->i_oparg > 0xffff)
+                    extended_arg_count++;
+            }
+        }
+
+    /* XXX: This is an awful hack that could hurt performance, but
+        on the bright side it should work until we come up
+        with a better solution.
+
+        The issue is that in the first loop blocksize() is called
+        which calls instrsize() which requires i_oparg be set
+        appropriately.          There is a bootstrap problem because
+        i_oparg is calculated in the second loop above.
+
+        So we loop until we stop seeing new EXTENDED_ARGs.
+        The only EXTENDED_ARGs that could be popping up are
+        ones in jump instructions.  So this should converge
+        fairly quickly.
+    */
+    } while (last_extended_arg_count != extended_arg_count);
 }
 
 static PyObject *
 dict_keys_inorder(PyObject *dict, int offset)
 {
-	PyObject *tuple, *k, *v;
-	Py_ssize_t i, pos = 0, size = PyDict_Size(dict);
-
-	tuple = PyTuple_New(size);
-	if (tuple == NULL)
-		return NULL;
-	while (PyDict_Next(dict, &pos, &k, &v)) {
-		i = PyInt_AS_LONG(v);
-		/* The keys of the dictionary are tuples. (see compiler_add_o)
-		   The object we want is always first, though. */
-		k = PyTuple_GET_ITEM(k, 0);
-		Py_INCREF(k);
-		assert((i - offset) < size);
-		assert((i - offset) >= 0);
-		PyTuple_SET_ITEM(tuple, i - offset, k);
-	}
-	return tuple;
+    PyObject *tuple, *k, *v;
+    Py_ssize_t i, pos = 0, size = PyDict_Size(dict);
+
+    tuple = PyTuple_New(size);
+    if (tuple == NULL)
+        return NULL;
+    while (PyDict_Next(dict, &pos, &k, &v)) {
+        i = PyInt_AS_LONG(v);
+        /* The keys of the dictionary are tuples. (see compiler_add_o)
+           The object we want is always first, though. */
+        k = PyTuple_GET_ITEM(k, 0);
+        Py_INCREF(k);
+        assert((i - offset) < size);
+        assert((i - offset) >= 0);
+        PyTuple_SET_ITEM(tuple, i - offset, k);
+    }
+    return tuple;
 }
 
 static int
 compute_code_flags(struct compiler *c)
 {
-	PySTEntryObject *ste = c->u->u_ste;
-	int flags = 0, n;
-	if (ste->ste_type != ModuleBlock)
-		flags |= CO_NEWLOCALS;
-	if (ste->ste_type == FunctionBlock) {
-		if (!ste->ste_unoptimized)
-			flags |= CO_OPTIMIZED;
-		if (ste->ste_nested)
-			flags |= CO_NESTED;
-		if (ste->ste_generator)
-			flags |= CO_GENERATOR;
-		if (ste->ste_varargs)
-			flags |= CO_VARARGS;
-		if (ste->ste_varkeywords)
-			flags |= CO_VARKEYWORDS;
-	}
-
-	/* (Only) inherit compilerflags in PyCF_MASK */
-	flags |= (c->c_flags->cf_flags & PyCF_MASK);
-
-	n = PyDict_Size(c->u->u_freevars);
-	if (n < 0)
-	    return -1;
-	if (n == 0) {
-	    n = PyDict_Size(c->u->u_cellvars);
-	    if (n < 0)
-		return -1;
-	    if (n == 0) {
-		flags |= CO_NOFREE;
-	    }
-	}
-
-	return flags;
+    PySTEntryObject *ste = c->u->u_ste;
+    int flags = 0, n;
+    if (ste->ste_type != ModuleBlock)
+        flags |= CO_NEWLOCALS;
+    if (ste->ste_type == FunctionBlock) {
+        if (!ste->ste_unoptimized)
+            flags |= CO_OPTIMIZED;
+        if (ste->ste_nested)
+            flags |= CO_NESTED;
+        if (ste->ste_generator)
+            flags |= CO_GENERATOR;
+        if (ste->ste_varargs)
+            flags |= CO_VARARGS;
+        if (ste->ste_varkeywords)
+            flags |= CO_VARKEYWORDS;
+    }
+
+    /* (Only) inherit compilerflags in PyCF_MASK */
+    flags |= (c->c_flags->cf_flags & PyCF_MASK);
+
+    n = PyDict_Size(c->u->u_freevars);
+    if (n < 0)
+        return -1;
+    if (n == 0) {
+        n = PyDict_Size(c->u->u_cellvars);
+        if (n < 0)
+        return -1;
+        if (n == 0) {
+        flags |= CO_NOFREE;
+        }
+    }
+
+    return flags;
 }
 
 static PyCodeObject *
 makecode(struct compiler *c, struct assembler *a)
 {
-	PyObject *tmp;
-	PyCodeObject *co = NULL;
-	PyObject *consts = NULL;
-	PyObject *names = NULL;
-	PyObject *varnames = NULL;
-	PyObject *filename = NULL;
-	PyObject *name = NULL;
-	PyObject *freevars = NULL;
-	PyObject *cellvars = NULL;
-	PyObject *bytecode = NULL;
-	int nlocals, flags;
-
-	tmp = dict_keys_inorder(c->u->u_consts, 0);
-	if (!tmp)
-		goto error;
-	consts = PySequence_List(tmp); /* optimize_code requires a list */
-	Py_DECREF(tmp);
-
-	names = dict_keys_inorder(c->u->u_names, 0);
-	varnames = dict_keys_inorder(c->u->u_varnames, 0);
-	if (!consts || !names || !varnames)
-		goto error;
-      
-	cellvars = dict_keys_inorder(c->u->u_cellvars, 0);
-	if (!cellvars)
-	    goto error;
-	freevars = dict_keys_inorder(c->u->u_freevars, PyTuple_Size(cellvars));
-	if (!freevars)
-	    goto error;
-	filename = PyString_FromString(c->c_filename);
-	if (!filename)
-		goto error;
-
-	nlocals = PyDict_Size(c->u->u_varnames);
-	flags = compute_code_flags(c);
-	if (flags < 0)
-		goto error;
-
-	bytecode = PyCode_Optimize(a->a_bytecode, consts, names, a->a_lnotab);
-	if (!bytecode)
-		goto error;
-
-	tmp = PyList_AsTuple(consts); /* PyCode_New requires a tuple */
-	if (!tmp)
-		goto error;
-	Py_DECREF(consts);
-	consts = tmp;
-
-	co = PyCode_New(c->u->u_argcount, nlocals, stackdepth(c), flags,
-			bytecode, consts, names, varnames,
-			freevars, cellvars,
-			filename, c->u->u_name,
-			c->u->u_firstlineno,
-			a->a_lnotab);
+    PyObject *tmp;
+    PyCodeObject *co = NULL;
+    PyObject *consts = NULL;
+    PyObject *names = NULL;
+    PyObject *varnames = NULL;
+    PyObject *filename = NULL;
+    PyObject *name = NULL;
+    PyObject *freevars = NULL;
+    PyObject *cellvars = NULL;
+    PyObject *bytecode = NULL;
+    int nlocals, flags;
+
+    tmp = dict_keys_inorder(c->u->u_consts, 0);
+    if (!tmp)
+        goto error;
+    consts = PySequence_List(tmp); /* optimize_code requires a list */
+    Py_DECREF(tmp);
+
+    names = dict_keys_inorder(c->u->u_names, 0);
+    varnames = dict_keys_inorder(c->u->u_varnames, 0);
+    if (!consts || !names || !varnames)
+        goto error;
+
+    cellvars = dict_keys_inorder(c->u->u_cellvars, 0);
+    if (!cellvars)
+        goto error;
+    freevars = dict_keys_inorder(c->u->u_freevars, PyTuple_Size(cellvars));
+    if (!freevars)
+        goto error;
+    filename = PyString_FromString(c->c_filename);
+    if (!filename)
+        goto error;
+
+    nlocals = PyDict_Size(c->u->u_varnames);
+    flags = compute_code_flags(c);
+    if (flags < 0)
+        goto error;
+
+    bytecode = PyCode_Optimize(a->a_bytecode, consts, names, a->a_lnotab);
+    if (!bytecode)
+        goto error;
+
+    tmp = PyList_AsTuple(consts); /* PyCode_New requires a tuple */
+    if (!tmp)
+        goto error;
+    Py_DECREF(consts);
+    consts = tmp;
+
+    co = PyCode_New(c->u->u_argcount, nlocals, stackdepth(c), flags,
+                    bytecode, consts, names, varnames,
+                    freevars, cellvars,
+                    filename, c->u->u_name,
+                    c->u->u_firstlineno,
+                    a->a_lnotab);
  error:
-	Py_XDECREF(consts);
-	Py_XDECREF(names);
-	Py_XDECREF(varnames);
-	Py_XDECREF(filename);
-	Py_XDECREF(name);
-	Py_XDECREF(freevars);
-	Py_XDECREF(cellvars);
-	Py_XDECREF(bytecode);
-	return co;
+    Py_XDECREF(consts);
+    Py_XDECREF(names);
+    Py_XDECREF(varnames);
+    Py_XDECREF(filename);
+    Py_XDECREF(name);
+    Py_XDECREF(freevars);
+    Py_XDECREF(cellvars);
+    Py_XDECREF(bytecode);
+    return co;
 }
 
 
@@ -3890,90 +3890,90 @@ makecode(struct compiler *c, struct assembler *a)
 static void
 dump_instr(const struct instr *i)
 {
-	const char *jrel = i->i_jrel ? "jrel " : "";
-	const char *jabs = i->i_jabs ? "jabs " : "";
-	char arg[128];
+    const char *jrel = i->i_jrel ? "jrel " : "";
+    const char *jabs = i->i_jabs ? "jabs " : "";
+    char arg[128];
 
-	*arg = '\0';
-	if (i->i_hasarg)
-		sprintf(arg, "arg: %d ", i->i_oparg);
+    *arg = '\0';
+    if (i->i_hasarg)
+        sprintf(arg, "arg: %d ", i->i_oparg);
 
-	fprintf(stderr, "line: %d, opcode: %d %s%s%s\n", 
-			i->i_lineno, i->i_opcode, arg, jabs, jrel);
+    fprintf(stderr, "line: %d, opcode: %d %s%s%s\n",
+                    i->i_lineno, i->i_opcode, arg, jabs, jrel);
 }
 
 static void
 dump_basicblock(const basicblock *b)
 {
-	const char *seen = b->b_seen ? "seen " : "";
-	const char *b_return = b->b_return ? "return " : "";
-	fprintf(stderr, "used: %d, depth: %d, offset: %d %s%s\n",
-		b->b_iused, b->b_startdepth, b->b_offset, seen, b_return);
-	if (b->b_instr) {
-		int i;
-		for (i = 0; i < b->b_iused; i++) {
-			fprintf(stderr, "  [%02d] ", i);
-			dump_instr(b->b_instr + i);
-		}
-	}
+    const char *seen = b->b_seen ? "seen " : "";
+    const char *b_return = b->b_return ? "return " : "";
+    fprintf(stderr, "used: %d, depth: %d, offset: %d %s%s\n",
+        b->b_iused, b->b_startdepth, b->b_offset, seen, b_return);
+    if (b->b_instr) {
+        int i;
+        for (i = 0; i < b->b_iused; i++) {
+            fprintf(stderr, "  [%02d] ", i);
+            dump_instr(b->b_instr + i);
+        }
+    }
 }
 #endif
 
 static PyCodeObject *
 assemble(struct compiler *c, int addNone)
 {
-	basicblock *b, *entryblock;
-	struct assembler a;
-	int i, j, nblocks;
-	PyCodeObject *co = NULL;
-
-	/* Make sure every block that falls off the end returns None.
-	   XXX NEXT_BLOCK() isn't quite right, because if the last
-	   block ends with a jump or return b_next shouldn't set.
-	 */
-	if (!c->u->u_curblock->b_return) {
-		NEXT_BLOCK(c);
-		if (addNone)
-			ADDOP_O(c, LOAD_CONST, Py_None, consts);
-		ADDOP(c, RETURN_VALUE);
-	}
-
-	nblocks = 0;
-	entryblock = NULL;
-	for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
-		nblocks++;
-		entryblock = b; 
-	}
-
-	/* Set firstlineno if it wasn't explicitly set. */
-	if (!c->u->u_firstlineno) {
-		if (entryblock && entryblock->b_instr)
-			c->u->u_firstlineno = entryblock->b_instr->i_lineno;
-		else
-			c->u->u_firstlineno = 1;
-	}
-	if (!assemble_init(&a, nblocks, c->u->u_firstlineno))
-		goto error;
-	dfs(c, entryblock, &a);
-
-	/* Can't modify the bytecode after computing jump offsets. */
-	assemble_jump_offsets(&a, c);
-
-	/* Emit code in reverse postorder from dfs. */
-	for (i = a.a_nblocks - 1; i >= 0; i--) {
-		b = a.a_postorder[i];
-		for (j = 0; j < b->b_iused; j++)
-			if (!assemble_emit(&a, &b->b_instr[j]))
-				goto error;
-	}
-
-	if (_PyString_Resize(&a.a_lnotab, a.a_lnotab_off) < 0)
-		goto error;
-	if (_PyString_Resize(&a.a_bytecode, a.a_offset) < 0)
-		goto error;
-
-	co = makecode(c, &a);
+    basicblock *b, *entryblock;
+    struct assembler a;
+    int i, j, nblocks;
+    PyCodeObject *co = NULL;
+
+    /* Make sure every block that falls off the end returns None.
+       XXX NEXT_BLOCK() isn't quite right, because if the last
+       block ends with a jump or return b_next shouldn't set.
+     */
+    if (!c->u->u_curblock->b_return) {
+        NEXT_BLOCK(c);
+        if (addNone)
+            ADDOP_O(c, LOAD_CONST, Py_None, consts);
+        ADDOP(c, RETURN_VALUE);
+    }
+
+    nblocks = 0;
+    entryblock = NULL;
+    for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
+        nblocks++;
+        entryblock = b;
+    }
+
+    /* Set firstlineno if it wasn't explicitly set. */
+    if (!c->u->u_firstlineno) {
+        if (entryblock && entryblock->b_instr)
+            c->u->u_firstlineno = entryblock->b_instr->i_lineno;
+        else
+            c->u->u_firstlineno = 1;
+    }
+    if (!assemble_init(&a, nblocks, c->u->u_firstlineno))
+        goto error;
+    dfs(c, entryblock, &a);
+
+    /* Can't modify the bytecode after computing jump offsets. */
+    assemble_jump_offsets(&a, c);
+
+    /* Emit code in reverse postorder from dfs. */
+    for (i = a.a_nblocks - 1; i >= 0; i--) {
+        b = a.a_postorder[i];
+        for (j = 0; j < b->b_iused; j++)
+            if (!assemble_emit(&a, &b->b_instr[j]))
+                goto error;
+    }
+
+    if (_PyString_Resize(&a.a_lnotab, a.a_lnotab_off) < 0)
+        goto error;
+    if (_PyString_Resize(&a.a_bytecode, a.a_offset) < 0)
+        goto error;
+
+    co = makecode(c, &a);
  error:
-	assemble_free(&a);
-	return co;
+    assemble_free(&a);
+    return co;
 }
diff --git a/Python/dynload_aix.c b/Python/dynload_aix.c
index 7a604f2..8d56d7d 100644
--- a/Python/dynload_aix.c
+++ b/Python/dynload_aix.c
@@ -4,10 +4,10 @@
 #include "Python.h"
 #include "importdl.h"
 
-#include <ctype.h>	/*  for isdigit()	  */
-#include <errno.h>	/*  for global errno      */
-#include <string.h>	/*  for strerror()        */
-#include <stdlib.h>	/*  for malloc(), free()  */
+#include <ctype.h>      /*  for isdigit()         */
+#include <errno.h>      /*  for global errno      */
+#include <string.h>     /*  for strerror()        */
+#include <stdlib.h>     /*  for malloc(), free()  */
 #include <sys/ldr.h>
 
 
@@ -22,85 +22,85 @@
 extern char *Py_GetProgramName(void);
 
 typedef struct Module {
-	struct Module *next;
-	void          *entry;
+    struct Module *next;
+    void          *entry;
 } Module, *ModulePtr;
 
 const struct filedescr _PyImport_DynLoadFiletab[] = {
-	{".so", "rb", C_EXTENSION},
-	{"module.so", "rb", C_EXTENSION},
-	{0, 0}
+    {".so", "rb", C_EXTENSION},
+    {"module.so", "rb", C_EXTENSION},
+    {0, 0}
 };
 
 static int
 aix_getoldmodules(void **modlistptr)
 {
-	register ModulePtr       modptr, prevmodptr;
-	register struct ld_info  *ldiptr;
-	register char            *ldibuf;
-	register int             errflag, bufsize = 1024;
-	register unsigned int    offset;
-	char *progname = Py_GetProgramName();
-	
-	/*
-	-- Get the list of loaded modules into ld_info structures.
-	*/
-	if ((ldibuf = malloc(bufsize)) == NULL) {
-		PyErr_SetString(PyExc_ImportError, strerror(errno));
-		return -1;
-	}
-	while ((errflag = loadquery(L_GETINFO, ldibuf, bufsize)) == -1
-	       && errno == ENOMEM) {
-		free(ldibuf);
-		bufsize += 1024;
-		if ((ldibuf = malloc(bufsize)) == NULL) {
-			PyErr_SetString(PyExc_ImportError, strerror(errno));
-			return -1;
-		}
-	}
-	if (errflag == -1) {
-		PyErr_SetString(PyExc_ImportError, strerror(errno));
-		return -1;
-	}
-	/*
-	-- Make the modules list from the ld_info structures.
-	*/
-	ldiptr = (struct ld_info *)ldibuf;
-	prevmodptr = NULL;
-	do {
-		if (strstr(progname, ldiptr->ldinfo_filename) == NULL &&
-		    strstr(ldiptr->ldinfo_filename, "python") == NULL) {
-			/*
-			-- Extract only the modules belonging to the main
-			-- executable + those containing "python" as a
-			-- substring (like the "python[version]" binary or
-			-- "libpython[version].a" in case it's a shared lib).
-			*/
-			offset = (unsigned int)ldiptr->ldinfo_next;
-			ldiptr = (struct ld_info *)((char*)ldiptr + offset);
-			continue;
-		}
-		if ((modptr = (ModulePtr)malloc(sizeof(Module))) == NULL) {
-			PyErr_SetString(PyExc_ImportError, strerror(errno));
-			while (*modlistptr) {
-				modptr = (ModulePtr)*modlistptr;
-				*modlistptr = (void *)modptr->next;
-				free(modptr);
-			}
-			return -1;
-		}
-		modptr->entry = ldiptr->ldinfo_dataorg;
-		modptr->next  = NULL;
-		if (prevmodptr == NULL)
-			*modlistptr = (void *)modptr;
-		else
-			prevmodptr->next = modptr;
-		prevmodptr = modptr;
-		offset = (unsigned int)ldiptr->ldinfo_next;
-		ldiptr = (struct ld_info *)((char*)ldiptr + offset);
-	} while (offset);
-	free(ldibuf);
-	return 0;
+    register ModulePtr       modptr, prevmodptr;
+    register struct ld_info  *ldiptr;
+    register char            *ldibuf;
+    register int             errflag, bufsize = 1024;
+    register unsigned int    offset;
+    char *progname = Py_GetProgramName();
+
+    /*
+    -- Get the list of loaded modules into ld_info structures.
+    */
+    if ((ldibuf = malloc(bufsize)) == NULL) {
+        PyErr_SetString(PyExc_ImportError, strerror(errno));
+        return -1;
+    }
+    while ((errflag = loadquery(L_GETINFO, ldibuf, bufsize)) == -1
+           && errno == ENOMEM) {
+        free(ldibuf);
+        bufsize += 1024;
+        if ((ldibuf = malloc(bufsize)) == NULL) {
+            PyErr_SetString(PyExc_ImportError, strerror(errno));
+            return -1;
+        }
+    }
+    if (errflag == -1) {
+        PyErr_SetString(PyExc_ImportError, strerror(errno));
+        return -1;
+    }
+    /*
+    -- Make the modules list from the ld_info structures.
+    */
+    ldiptr = (struct ld_info *)ldibuf;
+    prevmodptr = NULL;
+    do {
+        if (strstr(progname, ldiptr->ldinfo_filename) == NULL &&
+            strstr(ldiptr->ldinfo_filename, "python") == NULL) {
+            /*
+            -- Extract only the modules belonging to the main
+            -- executable + those containing "python" as a
+            -- substring (like the "python[version]" binary or
+            -- "libpython[version].a" in case it's a shared lib).
+            */
+            offset = (unsigned int)ldiptr->ldinfo_next;
+            ldiptr = (struct ld_info *)((char*)ldiptr + offset);
+            continue;
+        }
+        if ((modptr = (ModulePtr)malloc(sizeof(Module))) == NULL) {
+            PyErr_SetString(PyExc_ImportError, strerror(errno));
+            while (*modlistptr) {
+                modptr = (ModulePtr)*modlistptr;
+                *modlistptr = (void *)modptr->next;
+                free(modptr);
+            }
+            return -1;
+        }
+        modptr->entry = ldiptr->ldinfo_dataorg;
+        modptr->next  = NULL;
+        if (prevmodptr == NULL)
+            *modlistptr = (void *)modptr;
+        else
+            prevmodptr->next = modptr;
+        prevmodptr = modptr;
+        offset = (unsigned int)ldiptr->ldinfo_next;
+        ldiptr = (struct ld_info *)((char*)ldiptr + offset);
+    } while (offset);
+    free(ldibuf);
+    return 0;
 }
 
 
@@ -108,76 +108,76 @@ static void
 aix_loaderror(const char *pathname)
 {
 
-	char *message[1024], errbuf[1024];
-	register int i,j;
-
-	struct errtab { 
-		int errNo;
-		char *errstr;
-	} load_errtab[] = {
-		{L_ERROR_TOOMANY,	"too many errors, rest skipped."},
-		{L_ERROR_NOLIB,		"can't load library:"},
-		{L_ERROR_UNDEF,		"can't find symbol in library:"},
-		{L_ERROR_RLDBAD,
-		 "RLD index out of range or bad relocation type:"},
-		{L_ERROR_FORMAT,	"not a valid, executable xcoff file:"},
-		{L_ERROR_MEMBER,
-		 "file not an archive or does not contain requested member:"},
-		{L_ERROR_TYPE,		"symbol table mismatch:"},
-		{L_ERROR_ALIGN,		"text alignment in file is wrong."},
-		{L_ERROR_SYSTEM,	"System error:"},
-		{L_ERROR_ERRNO,		NULL}
-	};
-
-#define LOAD_ERRTAB_LEN	(sizeof(load_errtab)/sizeof(load_errtab[0]))
+    char *message[1024], errbuf[1024];
+    register int i,j;
+
+    struct errtab {
+        int errNo;
+        char *errstr;
+    } load_errtab[] = {
+        {L_ERROR_TOOMANY,               "too many errors, rest skipped."},
+        {L_ERROR_NOLIB,                 "can't load library:"},
+        {L_ERROR_UNDEF,                 "can't find symbol in library:"},
+        {L_ERROR_RLDBAD,
+         "RLD index out of range or bad relocation type:"},
+        {L_ERROR_FORMAT,                "not a valid, executable xcoff file:"},
+        {L_ERROR_MEMBER,
+         "file not an archive or does not contain requested member:"},
+        {L_ERROR_TYPE,                  "symbol table mismatch:"},
+        {L_ERROR_ALIGN,                 "text alignment in file is wrong."},
+        {L_ERROR_SYSTEM,                "System error:"},
+        {L_ERROR_ERRNO,                 NULL}
+    };
+
+#define LOAD_ERRTAB_LEN (sizeof(load_errtab)/sizeof(load_errtab[0]))
 #define ERRBUF_APPEND(s) strncat(errbuf, s, sizeof(errbuf)-strlen(errbuf)-1)
 
-	PyOS_snprintf(errbuf, sizeof(errbuf), "from module %.200s ", pathname);
-
-	if (!loadquery(L_GETMESSAGES, &message[0], sizeof(message))) {
-		ERRBUF_APPEND(strerror(errno));
-		ERRBUF_APPEND("\n");
-	}
-	for(i = 0; message[i] && *message[i]; i++) {
-		int nerr = atoi(message[i]);
-		for (j=0; j<LOAD_ERRTAB_LEN ; j++) {
-		    if (nerr == load_errtab[j].errNo && load_errtab[j].errstr)
-			ERRBUF_APPEND(load_errtab[j].errstr);
-		}
-		while (isdigit(Py_CHARMASK(*message[i]))) message[i]++ ; 
-		ERRBUF_APPEND(message[i]);
-		ERRBUF_APPEND("\n");
-	}
-	errbuf[strlen(errbuf)-1] = '\0';	/* trim off last newline */
-	PyErr_SetString(PyExc_ImportError, errbuf); 
-	return; 
+    PyOS_snprintf(errbuf, sizeof(errbuf), "from module %.200s ", pathname);
+
+    if (!loadquery(L_GETMESSAGES, &message[0], sizeof(message))) {
+        ERRBUF_APPEND(strerror(errno));
+        ERRBUF_APPEND("\n");
+    }
+    for(i = 0; message[i] && *message[i]; i++) {
+        int nerr = atoi(message[i]);
+        for (j=0; j<LOAD_ERRTAB_LEN ; j++) {
+            if (nerr == load_errtab[j].errNo && load_errtab[j].errstr)
+            ERRBUF_APPEND(load_errtab[j].errstr);
+        }
+        while (isdigit(Py_CHARMASK(*message[i]))) message[i]++ ;
+        ERRBUF_APPEND(message[i]);
+        ERRBUF_APPEND("\n");
+    }
+    errbuf[strlen(errbuf)-1] = '\0';            /* trim off last newline */
+    PyErr_SetString(PyExc_ImportError, errbuf);
+    return;
 }
 
 
 dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
-				    const char *pathname, FILE *fp)
+                                    const char *pathname, FILE *fp)
 {
-	dl_funcptr p;
-
-	/*
-	-- Invoke load() with L_NOAUTODEFER leaving the imported symbols
-	-- of the shared module unresolved. Thus we have to resolve them
-	-- explicitly with loadbind. The new module is loaded, then we
-	-- resolve its symbols using the list of already loaded modules
-	-- (only those that belong to the python executable). Get these
-	-- with loadquery(L_GETINFO).
-	*/
-
-	static void *staticmodlistptr = NULL;
-
-	if (!staticmodlistptr)
-		if (aix_getoldmodules(&staticmodlistptr) == -1)
-			return NULL;
-	p = (dl_funcptr) aix_load((char *)pathname, L_NOAUTODEFER, 0);
-	if (p == NULL) {
-		aix_loaderror(pathname);
-		return NULL;
-	}
-
-	return p;
+    dl_funcptr p;
+
+    /*
+    -- Invoke load() with L_NOAUTODEFER leaving the imported symbols
+    -- of the shared module unresolved. Thus we have to resolve them
+    -- explicitly with loadbind. The new module is loaded, then we
+    -- resolve its symbols using the list of already loaded modules
+    -- (only those that belong to the python executable). Get these
+    -- with loadquery(L_GETINFO).
+    */
+
+    static void *staticmodlistptr = NULL;
+
+    if (!staticmodlistptr)
+        if (aix_getoldmodules(&staticmodlistptr) == -1)
+            return NULL;
+    p = (dl_funcptr) aix_load((char *)pathname, L_NOAUTODEFER, 0);
+    if (p == NULL) {
+        aix_loaderror(pathname);
+        return NULL;
+    }
+
+    return p;
 }
diff --git a/Python/dynload_atheos.c b/Python/dynload_atheos.c
index 6f4df73..65e4136 100644
--- a/Python/dynload_atheos.c
+++ b/Python/dynload_atheos.c
@@ -9,39 +9,39 @@
 
 
 const struct filedescr _PyImport_DynLoadFiletab[] = {
-	{".so", "rb", C_EXTENSION},
-	{"module.so", "rb", C_EXTENSION},
-	{0, 0}
+    {".so", "rb", C_EXTENSION},
+    {"module.so", "rb", C_EXTENSION},
+    {0, 0}
 };
 
 dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
-				    const char *pathname, FILE *fp)
+                                    const char *pathname, FILE *fp)
 {
-	void *p;
-	int lib;
-	char funcname[258];
-
-	if (Py_VerboseFlag)
-		printf("load_library %s\n", pathname);
-
-	lib = load_library(pathname, 0);
-	if (lib < 0) {
-		char buf[512];
-		if (Py_VerboseFlag)
-			perror(pathname);
-		PyOS_snprintf(buf, sizeof(buf), "Failed to load %.200s: %.200s",
-			      pathname, strerror(errno));
-		PyErr_SetString(PyExc_ImportError, buf);
-		return NULL;
-	}
-	PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
-	if (Py_VerboseFlag)
-		printf("get_symbol_address %s\n", funcname);
-	if (get_symbol_address(lib, funcname, -1, &p) < 0) {
-		p = NULL;
-		if (Py_VerboseFlag)
-			perror(funcname);
-	}
-
-	return (dl_funcptr) p;
+    void *p;
+    int lib;
+    char funcname[258];
+
+    if (Py_VerboseFlag)
+        printf("load_library %s\n", pathname);
+
+    lib = load_library(pathname, 0);
+    if (lib < 0) {
+        char buf[512];
+        if (Py_VerboseFlag)
+            perror(pathname);
+        PyOS_snprintf(buf, sizeof(buf), "Failed to load %.200s: %.200s",
+                      pathname, strerror(errno));
+        PyErr_SetString(PyExc_ImportError, buf);
+        return NULL;
+    }
+    PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
+    if (Py_VerboseFlag)
+        printf("get_symbol_address %s\n", funcname);
+    if (get_symbol_address(lib, funcname, -1, &p) < 0) {
+        p = NULL;
+        if (Py_VerboseFlag)
+            perror(funcname);
+    }
+
+    return (dl_funcptr) p;
 }
diff --git a/Python/dynload_beos.c b/Python/dynload_beos.c
index 5b05d6b..f5ca1ec 100644
--- a/Python/dynload_beos.c
+++ b/Python/dynload_beos.c
@@ -9,9 +9,9 @@
 #include "importdl.h"
 
 const struct filedescr _PyImport_DynLoadFiletab[] = {
-	{".so", "rb", C_EXTENSION},
-	{"module.so", "rb", C_EXTENSION},
-	{0, 0}
+    {".so", "rb", C_EXTENSION},
+    {"module.so", "rb", C_EXTENSION},
+    {0, 0}
 };
 
 #if defined(MAXPATHLEN) && !defined(_SYS_PARAM_H)
@@ -52,13 +52,13 @@ static PyObject *beos_dyn_images = NULL;
  */
 static void beos_nuke_dyn( PyObject *item )
 {
-	status_t retval;
+    status_t retval;
 
-	if( item ) {
-		image_id id = (image_id)PyInt_AsLong( item );
-		
-		retval = unload_add_on( id );
-	}
+    if( item ) {
+        image_id id = (image_id)PyInt_AsLong( item );
+
+        retval = unload_add_on( id );
+    }
 }
 
 /* atexit() handler that'll call unload_add_on() for every item in the
@@ -66,31 +66,31 @@ static void beos_nuke_dyn( PyObject *item )
  */
 static void beos_cleanup_dyn( void )
 {
-	if( beos_dyn_images ) {
-		int idx;
-		int list_size;
-		PyObject *id_list;
+    if( beos_dyn_images ) {
+        int idx;
+        int list_size;
+        PyObject *id_list;
 
 #ifdef WITH_THREAD
-		PyThread_acquire_lock( beos_dyn_lock, 1 );
+        PyThread_acquire_lock( beos_dyn_lock, 1 );
 #endif
 
-		id_list = PyDict_Values( beos_dyn_images );
+        id_list = PyDict_Values( beos_dyn_images );
+
+        list_size = PyList_Size( id_list );
+        for( idx = 0; idx < list_size; idx++ ) {
+            PyObject *the_item;
 
-		list_size = PyList_Size( id_list );
-		for( idx = 0; idx < list_size; idx++ ) {
-			PyObject *the_item;
-			
-			the_item = PyList_GetItem( id_list, idx );
-			beos_nuke_dyn( the_item );
-		}
+            the_item = PyList_GetItem( id_list, idx );
+            beos_nuke_dyn( the_item );
+        }
 
-		PyDict_Clear( beos_dyn_images );
+        PyDict_Clear( beos_dyn_images );
 
 #ifdef WITH_THREAD
-		PyThread_free_lock( beos_dyn_lock );
+        PyThread_free_lock( beos_dyn_lock );
 #endif
-	}
+    }
 }
 
 /*
@@ -98,20 +98,20 @@ static void beos_cleanup_dyn( void )
  */
 static void beos_init_dyn( void )
 {
-	/* We're protected from a race condition here by the atomic init_count
-	 * variable.
-	 */
-	static int32 init_count = 0;
-	int32 val;
-
-	val = atomic_add( &init_count, 1 );
-	if( beos_dyn_images == NULL && val == 0 ) {
-		beos_dyn_images = PyDict_New();
+    /* We're protected from a race condition here by the atomic init_count
+     * variable.
+     */
+    static int32 init_count = 0;
+    int32 val;
+
+    val = atomic_add( &init_count, 1 );
+    if( beos_dyn_images == NULL && val == 0 ) {
+        beos_dyn_images = PyDict_New();
 #ifdef WITH_THREAD
-		beos_dyn_lock = PyThread_allocate_lock();
+        beos_dyn_lock = PyThread_allocate_lock();
 #endif
-		atexit( beos_cleanup_dyn );
-	}
+        atexit( beos_cleanup_dyn );
+    }
 }
 
 /*
@@ -122,133 +122,133 @@ static void beos_init_dyn( void )
  */
 static void beos_add_dyn( char *name, image_id id )
 {
-	int retval;
-	PyObject *py_id;
+    int retval;
+    PyObject *py_id;
 
-	if( beos_dyn_images == NULL ) {
-		beos_init_dyn();
-	}
+    if( beos_dyn_images == NULL ) {
+        beos_init_dyn();
+    }
 
 #ifdef WITH_THREAD
-	retval = PyThread_acquire_lock( beos_dyn_lock, 1 );
+    retval = PyThread_acquire_lock( beos_dyn_lock, 1 );
 #endif
 
-	/* If there's already an object with this key in the dictionary,
-	 * we're doing a reload(), so let's nuke it.
-	 */
-	py_id = PyDict_GetItemString( beos_dyn_images, name );
-	if( py_id ) {
-		beos_nuke_dyn( py_id );
-		retval = PyDict_DelItemString( beos_dyn_images, name );
-	}
+    /* If there's already an object with this key in the dictionary,
+     * we're doing a reload(), so let's nuke it.
+     */
+    py_id = PyDict_GetItemString( beos_dyn_images, name );
+    if( py_id ) {
+        beos_nuke_dyn( py_id );
+        retval = PyDict_DelItemString( beos_dyn_images, name );
+    }
 
-	py_id = PyInt_FromLong( (long)id );
-	if( py_id ) {
-		retval = PyDict_SetItemString( beos_dyn_images, name, py_id );
-	}
+    py_id = PyInt_FromLong( (long)id );
+    if( py_id ) {
+        retval = PyDict_SetItemString( beos_dyn_images, name, py_id );
+    }
 
 #ifdef WITH_THREAD
-	PyThread_release_lock( beos_dyn_lock );
+    PyThread_release_lock( beos_dyn_lock );
 #endif
 }
 
 
 
 dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
-				    const char *pathname, FILE *fp)
+                                    const char *pathname, FILE *fp)
 {
-	dl_funcptr p;
-	image_id the_id;
-	status_t retval;
-	char fullpath[PATH_MAX];
-	char funcname[258];
-
-	if( Py_VerboseFlag ) {
-		printf( "load_add_on( %s )\n", pathname );
-	}
-
-	/* Hmm, this old bug appears to have regenerated itself; if the
-	 * path isn't absolute, load_add_on() will fail.  Reported to Be
-	 * April 21, 1998.
-	 */
-	if( pathname[0] != '/' ) {
-		(void)getcwd( fullpath, PATH_MAX );
-		(void)strncat( fullpath, "/", PATH_MAX );
-		(void)strncat( fullpath, pathname, PATH_MAX );
-			
-		if( Py_VerboseFlag ) {
-			printf( "load_add_on( %s )\n", fullpath );
-		}
-	} else {
-		(void)strcpy( fullpath, pathname );
-	}
-
-	the_id = load_add_on( fullpath );
-	if( the_id < B_NO_ERROR ) {
-		/* It's too bad load_add_on() doesn't set errno or something...
-		 */
-		char buff[256];  /* hate hard-coded string sizes... */
-
-		if( Py_VerboseFlag ) {
-			printf( "load_add_on( %s ) failed", fullpath );
-		}
-
-		if( the_id == B_ERROR )
-			PyOS_snprintf( buff, sizeof(buff),
-				       "BeOS: Failed to load %.200s",
-				       fullpath );
-		else
-			PyOS_snprintf( buff, sizeof(buff), 
-				       "Unknown error loading %.200s", 
-				       fullpath );
-
-		PyErr_SetString( PyExc_ImportError, buff );
-		return NULL;
-	}
-
-	PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
-	if( Py_VerboseFlag ) {
-		printf( "get_image_symbol( %s )\n", funcname );
-	}
-
-	retval = get_image_symbol( the_id, funcname, B_SYMBOL_TYPE_TEXT, &p );
-	if( retval != B_NO_ERROR || p == NULL ) {
-		/* That's bad, we can't find that symbol in the module...
-		 */
-		char buff[256];  /* hate hard-coded string sizes... */
-
-		if( Py_VerboseFlag ) {
-			printf( "get_image_symbol( %s ) failed", funcname );
-		}
-
-		switch( retval ) {
-		case B_BAD_IMAGE_ID:
-			PyOS_snprintf( buff, sizeof(buff),
-			       "can't load init function for dynamic module: "
-		               "Invalid image ID for %.180s", fullpath );
-			break;
-		case B_BAD_INDEX:
-			PyOS_snprintf( buff, sizeof(buff),
-			       "can't load init function for dynamic module: "
-		               "Bad index for %.180s", funcname );
-			break;
-		default:
-			PyOS_snprintf( buff, sizeof(buff),
-			       "can't load init function for dynamic module: "
-		               "Unknown error looking up %.180s", funcname );
-			break;
-		}
-
-		retval = unload_add_on( the_id );
-
-		PyErr_SetString( PyExc_ImportError, buff );
-		return NULL;
-	}
-
-	/* Save the module name and image ID for later so we can clean up
-	 * gracefully.
-	 */
-	beos_add_dyn( fqname, the_id );
-
-	return p;
+    dl_funcptr p;
+    image_id the_id;
+    status_t retval;
+    char fullpath[PATH_MAX];
+    char funcname[258];
+
+    if( Py_VerboseFlag ) {
+        printf( "load_add_on( %s )\n", pathname );
+    }
+
+    /* Hmm, this old bug appears to have regenerated itself; if the
+     * path isn't absolute, load_add_on() will fail.  Reported to Be
+     * April 21, 1998.
+     */
+    if( pathname[0] != '/' ) {
+        (void)getcwd( fullpath, PATH_MAX );
+        (void)strncat( fullpath, "/", PATH_MAX );
+        (void)strncat( fullpath, pathname, PATH_MAX );
+
+        if( Py_VerboseFlag ) {
+            printf( "load_add_on( %s )\n", fullpath );
+        }
+    } else {
+        (void)strcpy( fullpath, pathname );
+    }
+
+    the_id = load_add_on( fullpath );
+    if( the_id < B_NO_ERROR ) {
+        /* It's too bad load_add_on() doesn't set errno or something...
+         */
+        char buff[256];  /* hate hard-coded string sizes... */
+
+        if( Py_VerboseFlag ) {
+            printf( "load_add_on( %s ) failed", fullpath );
+        }
+
+        if( the_id == B_ERROR )
+            PyOS_snprintf( buff, sizeof(buff),
+                           "BeOS: Failed to load %.200s",
+                           fullpath );
+        else
+            PyOS_snprintf( buff, sizeof(buff),
+                           "Unknown error loading %.200s",
+                           fullpath );
+
+        PyErr_SetString( PyExc_ImportError, buff );
+        return NULL;
+    }
+
+    PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
+    if( Py_VerboseFlag ) {
+        printf( "get_image_symbol( %s )\n", funcname );
+    }
+
+    retval = get_image_symbol( the_id, funcname, B_SYMBOL_TYPE_TEXT, &p );
+    if( retval != B_NO_ERROR || p == NULL ) {
+        /* That's bad, we can't find that symbol in the module...
+         */
+        char buff[256];  /* hate hard-coded string sizes... */
+
+        if( Py_VerboseFlag ) {
+            printf( "get_image_symbol( %s ) failed", funcname );
+        }
+
+        switch( retval ) {
+        case B_BAD_IMAGE_ID:
+            PyOS_snprintf( buff, sizeof(buff),
+                   "can't load init function for dynamic module: "
+                   "Invalid image ID for %.180s", fullpath );
+            break;
+        case B_BAD_INDEX:
+            PyOS_snprintf( buff, sizeof(buff),
+                   "can't load init function for dynamic module: "
+                   "Bad index for %.180s", funcname );
+            break;
+        default:
+            PyOS_snprintf( buff, sizeof(buff),
+                   "can't load init function for dynamic module: "
+                   "Unknown error looking up %.180s", funcname );
+            break;
+        }
+
+        retval = unload_add_on( the_id );
+
+        PyErr_SetString( PyExc_ImportError, buff );
+        return NULL;
+    }
+
+    /* Save the module name and image ID for later so we can clean up
+     * gracefully.
+     */
+    beos_add_dyn( fqname, the_id );
+
+    return p;
 }
diff --git a/Python/dynload_hpux.c b/Python/dynload_hpux.c
index fec0826..c6ce16e 100644
--- a/Python/dynload_hpux.c
+++ b/Python/dynload_hpux.c
@@ -14,45 +14,45 @@
 #endif
 
 const struct filedescr _PyImport_DynLoadFiletab[] = {
-	{SHLIB_EXT, "rb", C_EXTENSION},
-	{"module"SHLIB_EXT, "rb", C_EXTENSION},
-	{0, 0}
+    {SHLIB_EXT, "rb", C_EXTENSION},
+    {"module"SHLIB_EXT, "rb", C_EXTENSION},
+    {0, 0}
 };
 
 dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
-				    const char *pathname, FILE *fp)
+                                    const char *pathname, FILE *fp)
 {
-	dl_funcptr p;
-	shl_t lib;
-	int flags;
-	char funcname[258];
-
-	flags = BIND_FIRST | BIND_DEFERRED;
-	if (Py_VerboseFlag) {
-		flags = BIND_FIRST | BIND_IMMEDIATE |
-			BIND_NONFATAL | BIND_VERBOSE;
-		printf("shl_load %s\n",pathname);
-	}
-	lib = shl_load(pathname, flags, 0);
-	/* XXX Chuck Blake once wrote that 0 should be BIND_NOSTART? */
-	if (lib == NULL) {
-		char buf[256];
-		if (Py_VerboseFlag)
-			perror(pathname);
-		PyOS_snprintf(buf, sizeof(buf), "Failed to load %.200s",
-			      pathname);
-		PyErr_SetString(PyExc_ImportError, buf);
-		return NULL;
-	}
-	PyOS_snprintf(funcname, sizeof(funcname), FUNCNAME_PATTERN, shortname);
-	if (Py_VerboseFlag)
-		printf("shl_findsym %s\n", funcname);
-	if (shl_findsym(&lib, funcname, TYPE_UNDEFINED, (void *) &p) == -1) {
-		shl_unload(lib);
-		p = NULL;
-	}
-	if (p == NULL && Py_VerboseFlag)
-		perror(funcname);
-
-	return p;
+    dl_funcptr p;
+    shl_t lib;
+    int flags;
+    char funcname[258];
+
+    flags = BIND_FIRST | BIND_DEFERRED;
+    if (Py_VerboseFlag) {
+        flags = BIND_FIRST | BIND_IMMEDIATE |
+            BIND_NONFATAL | BIND_VERBOSE;
+        printf("shl_load %s\n",pathname);
+    }
+    lib = shl_load(pathname, flags, 0);
+    /* XXX Chuck Blake once wrote that 0 should be BIND_NOSTART? */
+    if (lib == NULL) {
+        char buf[256];
+        if (Py_VerboseFlag)
+            perror(pathname);
+        PyOS_snprintf(buf, sizeof(buf), "Failed to load %.200s",
+                      pathname);
+        PyErr_SetString(PyExc_ImportError, buf);
+        return NULL;
+    }
+    PyOS_snprintf(funcname, sizeof(funcname), FUNCNAME_PATTERN, shortname);
+    if (Py_VerboseFlag)
+        printf("shl_findsym %s\n", funcname);
+    if (shl_findsym(&lib, funcname, TYPE_UNDEFINED, (void *) &p) == -1) {
+        shl_unload(lib);
+        p = NULL;
+    }
+    if (p == NULL && Py_VerboseFlag)
+        perror(funcname);
+
+    return p;
 }
diff --git a/Python/dynload_next.c b/Python/dynload_next.c
index 27df356..7e61b5d 100644
--- a/Python/dynload_next.c
+++ b/Python/dynload_next.c
@@ -9,9 +9,9 @@
 #include <mach-o/dyld.h>
 
 const struct filedescr _PyImport_DynLoadFiletab[] = {
-	{".so", "rb", C_EXTENSION},
-	{"module.so", "rb", C_EXTENSION},
-	{0, 0}
+    {".so", "rb", C_EXTENSION},
+    {"module.so", "rb", C_EXTENSION},
+    {0, 0}
 };
 
 /*
@@ -29,86 +29,86 @@ const struct filedescr _PyImport_DynLoadFiletab[] = {
 #define LINKOPTIONS NSLINKMODULE_OPTION_BINDNOW|NSLINKMODULE_OPTION_RETURN_ON_ERROR
 #else
 #define LINKOPTIONS NSLINKMODULE_OPTION_BINDNOW| \
-	NSLINKMODULE_OPTION_RETURN_ON_ERROR|NSLINKMODULE_OPTION_PRIVATE
+    NSLINKMODULE_OPTION_RETURN_ON_ERROR|NSLINKMODULE_OPTION_PRIVATE
 #endif
 dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
-					const char *pathname, FILE *fp)
+                                        const char *pathname, FILE *fp)
 {
-	dl_funcptr p = NULL;
-	char funcname[258];
-	NSObjectFileImageReturnCode rc;
-	NSObjectFileImage image;
-	NSModule newModule;
-	NSSymbol theSym;
-	const char *errString;
-	char errBuf[512];
+    dl_funcptr p = NULL;
+    char funcname[258];
+    NSObjectFileImageReturnCode rc;
+    NSObjectFileImage image;
+    NSModule newModule;
+    NSSymbol theSym;
+    const char *errString;
+    char errBuf[512];
 
-	PyOS_snprintf(funcname, sizeof(funcname), "_init%.200s", shortname);
+    PyOS_snprintf(funcname, sizeof(funcname), "_init%.200s", shortname);
 
 #ifdef USE_DYLD_GLOBAL_NAMESPACE
-	if (NSIsSymbolNameDefined(funcname)) {
-		theSym = NSLookupAndBindSymbol(funcname);
-		p = (dl_funcptr)NSAddressOfSymbol(theSym);
-		return p;
-	}
+    if (NSIsSymbolNameDefined(funcname)) {
+        theSym = NSLookupAndBindSymbol(funcname);
+        p = (dl_funcptr)NSAddressOfSymbol(theSym);
+        return p;
+    }
 #endif
-	rc = NSCreateObjectFileImageFromFile(pathname, &image);
-	switch(rc) {
-		default:
-		case NSObjectFileImageFailure:
-		case NSObjectFileImageFormat:
-			/* for these a message is printed on stderr by dyld */
-			errString = "Can't create object file image";
-		break;
-		case NSObjectFileImageSuccess:
-			errString = NULL;
-			break;
-		case NSObjectFileImageInappropriateFile:
-			errString = "Inappropriate file type for dynamic loading";
-			break;
-		case NSObjectFileImageArch:
-			errString = "Wrong CPU type in object file";
-			break;
-		case NSObjectFileImageAccess:
-			errString = "Can't read object file (no access)";
-			break;
-	}
-	if (errString == NULL) {
-		newModule = NSLinkModule(image, pathname, LINKOPTIONS);
-		if (newModule == NULL) {
-			int errNo;
-			const char *fileName, *moreErrorStr;
-			NSLinkEditErrors c;
-			NSLinkEditError( &c, &errNo, &fileName, &moreErrorStr );
-			PyOS_snprintf(errBuf, 512, "Failure linking new module: %s: %s", 
-					fileName, moreErrorStr);
-			errString = errBuf;
-		}
-	}
-	if (errString != NULL) {
-		PyErr_SetString(PyExc_ImportError, errString);
-		return NULL;
-	}
+    rc = NSCreateObjectFileImageFromFile(pathname, &image);
+    switch(rc) {
+        default:
+        case NSObjectFileImageFailure:
+        case NSObjectFileImageFormat:
+            /* for these a message is printed on stderr by dyld */
+            errString = "Can't create object file image";
+        break;
+        case NSObjectFileImageSuccess:
+            errString = NULL;
+            break;
+        case NSObjectFileImageInappropriateFile:
+            errString = "Inappropriate file type for dynamic loading";
+            break;
+        case NSObjectFileImageArch:
+            errString = "Wrong CPU type in object file";
+            break;
+        case NSObjectFileImageAccess:
+            errString = "Can't read object file (no access)";
+            break;
+    }
+    if (errString == NULL) {
+        newModule = NSLinkModule(image, pathname, LINKOPTIONS);
+        if (newModule == NULL) {
+            int errNo;
+            const char *fileName, *moreErrorStr;
+            NSLinkEditErrors c;
+            NSLinkEditError( &c, &errNo, &fileName, &moreErrorStr );
+            PyOS_snprintf(errBuf, 512, "Failure linking new module: %s: %s",
+                            fileName, moreErrorStr);
+            errString = errBuf;
+        }
+    }
+    if (errString != NULL) {
+        PyErr_SetString(PyExc_ImportError, errString);
+        return NULL;
+    }
 #ifdef USE_DYLD_GLOBAL_NAMESPACE
-	if (!NSIsSymbolNameDefined(funcname)) {
-		/* UnlinkModule() isn't implemented in current versions, but calling it does no harm */
-		/* NSUnLinkModule(newModule, FALSE); removed: causes problems for ObjC code */
-		PyErr_Format(PyExc_ImportError,
-				 "Loaded module does not contain symbol %.200s",
-				 funcname);
-		return NULL;
-	}
-	theSym = NSLookupAndBindSymbol(funcname);
+    if (!NSIsSymbolNameDefined(funcname)) {
+        /* UnlinkModule() isn't implemented in current versions, but calling it does no harm */
+        /* NSUnLinkModule(newModule, FALSE); removed: causes problems for ObjC code */
+        PyErr_Format(PyExc_ImportError,
+                         "Loaded module does not contain symbol %.200s",
+                         funcname);
+        return NULL;
+    }
+    theSym = NSLookupAndBindSymbol(funcname);
 #else
-	theSym = NSLookupSymbolInModule(newModule, funcname);
-	if ( theSym == NULL ) {
-		/* NSUnLinkModule(newModule, FALSE); removed: causes problems for ObjC code */
-		PyErr_Format(PyExc_ImportError,
-				 "Loaded module does not contain symbol %.200s",
-				 funcname);
-		return NULL;
-	}
+    theSym = NSLookupSymbolInModule(newModule, funcname);
+    if ( theSym == NULL ) {
+        /* NSUnLinkModule(newModule, FALSE); removed: causes problems for ObjC code */
+        PyErr_Format(PyExc_ImportError,
+                         "Loaded module does not contain symbol %.200s",
+                         funcname);
+        return NULL;
+    }
 #endif
-	p = (dl_funcptr)NSAddressOfSymbol(theSym);
-	return p;
+    p = (dl_funcptr)NSAddressOfSymbol(theSym);
+    return p;
 }
diff --git a/Python/dynload_os2.c b/Python/dynload_os2.c
index d660e27..e3fdb70 100644
--- a/Python/dynload_os2.c
+++ b/Python/dynload_os2.c
@@ -10,37 +10,37 @@
 
 
 const struct filedescr _PyImport_DynLoadFiletab[] = {
-	{".pyd", "rb", C_EXTENSION},
-	{".dll", "rb", C_EXTENSION},
-	{0, 0}
+    {".pyd", "rb", C_EXTENSION},
+    {".dll", "rb", C_EXTENSION},
+    {0, 0}
 };
 
 dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
-				    const char *pathname, FILE *fp)
+                                    const char *pathname, FILE *fp)
 {
-	dl_funcptr p;
-	APIRET  rc;
-	HMODULE hDLL;
-	char failreason[256];
-	char funcname[258];
-
-	rc = DosLoadModule(failreason,
-			   sizeof(failreason),
-			   pathname,
-			   &hDLL);
-
-	if (rc != NO_ERROR) {
-		char errBuf[256];
-		PyOS_snprintf(errBuf, sizeof(errBuf),
-			      "DLL load failed, rc = %d: %.200s",
-			      rc, failreason);
-		PyErr_SetString(PyExc_ImportError, errBuf);
-		return NULL;
-	}
-
-	PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
-	rc = DosQueryProcAddr(hDLL, 0L, funcname, &p);
-	if (rc != NO_ERROR)
-		p = NULL; /* Signify Failure to Acquire Entrypoint */
-	return p;
+    dl_funcptr p;
+    APIRET  rc;
+    HMODULE hDLL;
+    char failreason[256];
+    char funcname[258];
+
+    rc = DosLoadModule(failreason,
+                       sizeof(failreason),
+                       pathname,
+                       &hDLL);
+
+    if (rc != NO_ERROR) {
+        char errBuf[256];
+        PyOS_snprintf(errBuf, sizeof(errBuf),
+                      "DLL load failed, rc = %d: %.200s",
+                      rc, failreason);
+        PyErr_SetString(PyExc_ImportError, errBuf);
+        return NULL;
+    }
+
+    PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
+    rc = DosQueryProcAddr(hDLL, 0L, funcname, &p);
+    if (rc != NO_ERROR)
+        p = NULL; /* Signify Failure to Acquire Entrypoint */
+    return p;
 }
diff --git a/Python/dynload_shlib.c b/Python/dynload_shlib.c
index f12a93c..17ebab1 100644
--- a/Python/dynload_shlib.c
+++ b/Python/dynload_shlib.c
@@ -33,111 +33,111 @@
 
 const struct filedescr _PyImport_DynLoadFiletab[] = {
 #ifdef __CYGWIN__
-	{".dll", "rb", C_EXTENSION},
-	{"module.dll", "rb", C_EXTENSION},
+    {".dll", "rb", C_EXTENSION},
+    {"module.dll", "rb", C_EXTENSION},
 #else
 #if defined(PYOS_OS2) && defined(PYCC_GCC)
-	{".pyd", "rb", C_EXTENSION},
-	{".dll", "rb", C_EXTENSION},
+    {".pyd", "rb", C_EXTENSION},
+    {".dll", "rb", C_EXTENSION},
 #else
 #ifdef __VMS
-        {".exe", "rb", C_EXTENSION},
-        {".EXE", "rb", C_EXTENSION},
-        {"module.exe", "rb", C_EXTENSION},
-        {"MODULE.EXE", "rb", C_EXTENSION},
+    {".exe", "rb", C_EXTENSION},
+    {".EXE", "rb", C_EXTENSION},
+    {"module.exe", "rb", C_EXTENSION},
+    {"MODULE.EXE", "rb", C_EXTENSION},
 #else
-	{".so", "rb", C_EXTENSION},
-	{"module.so", "rb", C_EXTENSION},
+    {".so", "rb", C_EXTENSION},
+    {"module.so", "rb", C_EXTENSION},
 #endif
 #endif
 #endif
-	{0, 0}
+    {0, 0}
 };
 
 static struct {
-	dev_t dev;
+    dev_t dev;
 #ifdef __VMS
-	ino_t ino[3];
+    ino_t ino[3];
 #else
-	ino_t ino;
+    ino_t ino;
 #endif
-	void *handle;
+    void *handle;
 } handles[128];
 static int nhandles = 0;
 
 
 dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
-				    const char *pathname, FILE *fp)
+                                    const char *pathname, FILE *fp)
 {
-	dl_funcptr p;
-	void *handle;
-	char funcname[258];
-	char pathbuf[260];
-        int dlopenflags=0;
-
-	if (strchr(pathname, '/') == NULL) {
-		/* Prefix bare filename with "./" */
-		PyOS_snprintf(pathbuf, sizeof(pathbuf), "./%-.255s", pathname);
-		pathname = pathbuf;
-	}
-
-	PyOS_snprintf(funcname, sizeof(funcname), 
-		      LEAD_UNDERSCORE "init%.200s", shortname);
-
-	if (fp != NULL) {
-		int i;
-		struct stat statb;
-		fstat(fileno(fp), &statb);
-		for (i = 0; i < nhandles; i++) {
-			if (statb.st_dev == handles[i].dev &&
-			    statb.st_ino == handles[i].ino) {
-				p = (dl_funcptr) dlsym(handles[i].handle,
-						       funcname);
-				return p;
-			}
-		}
-		if (nhandles < 128) {
-			handles[nhandles].dev = statb.st_dev;
+    dl_funcptr p;
+    void *handle;
+    char funcname[258];
+    char pathbuf[260];
+    int dlopenflags=0;
+
+    if (strchr(pathname, '/') == NULL) {
+        /* Prefix bare filename with "./" */
+        PyOS_snprintf(pathbuf, sizeof(pathbuf), "./%-.255s", pathname);
+        pathname = pathbuf;
+    }
+
+    PyOS_snprintf(funcname, sizeof(funcname),
+                  LEAD_UNDERSCORE "init%.200s", shortname);
+
+    if (fp != NULL) {
+        int i;
+        struct stat statb;
+        fstat(fileno(fp), &statb);
+        for (i = 0; i < nhandles; i++) {
+            if (statb.st_dev == handles[i].dev &&
+                statb.st_ino == handles[i].ino) {
+                p = (dl_funcptr) dlsym(handles[i].handle,
+                                       funcname);
+                return p;
+            }
+        }
+        if (nhandles < 128) {
+            handles[nhandles].dev = statb.st_dev;
 #ifdef __VMS
-			handles[nhandles].ino[0] = statb.st_ino[0];
-			handles[nhandles].ino[1] = statb.st_ino[1];
-			handles[nhandles].ino[2] = statb.st_ino[2];
+            handles[nhandles].ino[0] = statb.st_ino[0];
+            handles[nhandles].ino[1] = statb.st_ino[1];
+            handles[nhandles].ino[2] = statb.st_ino[2];
 #else
-			handles[nhandles].ino = statb.st_ino;
+            handles[nhandles].ino = statb.st_ino;
 #endif
-		}
-	}
+        }
+    }
 
 #if !(defined(PYOS_OS2) && defined(PYCC_GCC))
-        dlopenflags = PyThreadState_GET()->interp->dlopenflags;
+    dlopenflags = PyThreadState_GET()->interp->dlopenflags;
 #endif
 
-	if (Py_VerboseFlag)
-		PySys_WriteStderr("dlopen(\"%s\", %x);\n", pathname, 
-				  dlopenflags);
+    if (Py_VerboseFlag)
+        PySys_WriteStderr("dlopen(\"%s\", %x);\n", pathname,
+                          dlopenflags);
 
 #ifdef __VMS
-	/* VMS currently don't allow a pathname, use a logical name instead */
-	/* Concatenate 'python_module_' and shortname */
-	/* so "import vms.bar" will use the logical python_module_bar */
-	/* As C module use only one name space this is probably not a */
-	/* important limitation */
-	PyOS_snprintf(pathbuf, sizeof(pathbuf), "python_module_%-.200s", 
-		      shortname);
-	pathname = pathbuf;
+    /* VMS currently don't allow a pathname, use a logical name instead */
+    /* Concatenate 'python_module_' and shortname */
+    /* so "import vms.bar" will use the logical python_module_bar */
+    /* As C module use only one name space this is probably not a */
+    /* important limitation */
+    PyOS_snprintf(pathbuf, sizeof(pathbuf), "python_module_%-.200s",
+                  shortname);
+    pathname = pathbuf;
 #endif
 
-	handle = dlopen(pathname, dlopenflags);
-
-	if (handle == NULL) {
-		const char *error = dlerror();
-		if (error == NULL)
-			error = "unknown dlopen() error";
-		PyErr_SetString(PyExc_ImportError, error);
-		return NULL;
-	}
-	if (fp != NULL && nhandles < 128)
-		handles[nhandles++].handle = handle;
-	p = (dl_funcptr) dlsym(handle, funcname);
-	return p;
+    handle = dlopen(pathname, dlopenflags);
+
+    if (handle == NULL) {
+        const char *error = dlerror();
+        if (error == NULL)
+            error = "unknown dlopen() error";
+        PyErr_SetString(PyExc_ImportError, error);
+        return NULL;
+    }
+    if (fp != NULL && nhandles < 128)
+        handles[nhandles++].handle = handle;
+    p = (dl_funcptr) dlsym(handle, funcname);
+    return p;
 }
diff --git a/Python/dynload_win.c b/Python/dynload_win.c
index 907a5a3..4e5555e 100644
--- a/Python/dynload_win.c
+++ b/Python/dynload_win.c
@@ -17,11 +17,11 @@ void _Py_DeactivateActCtx(ULONG_PTR cookie);
 
 const struct filedescr _PyImport_DynLoadFiletab[] = {
 #ifdef _DEBUG
-	{"_d.pyd", "rb", C_EXTENSION},
+    {"_d.pyd", "rb", C_EXTENSION},
 #else
-	{".pyd", "rb", C_EXTENSION},
+    {".pyd", "rb", C_EXTENSION},
 #endif
-	{0, 0}
+    {0, 0}
 };
 
 
@@ -29,18 +29,18 @@ const struct filedescr _PyImport_DynLoadFiletab[] = {
    C RTL implementations */
 
 static int strcasecmp (char *string1, char *string2)
-{ 
-	int first, second;
+{
+    int first, second;
 
-	do {
-		first  = tolower(*string1);
-		second = tolower(*string2);
-		string1++;
-		string2++;
-	} while (first && first == second);
+    do {
+        first  = tolower(*string1);
+        second = tolower(*string2);
+        string1++;
+        string2++;
+    } while (first && first == second);
 
-	return (first - second);
-} 
+    return (first - second);
+}
 
 
 /* Function to return the name of the "python" DLL that the supplied module
@@ -66,209 +66,209 @@ static int strcasecmp (char *string1, char *string2)
 
 static char *GetPythonImport (HINSTANCE hModule)
 {
-	unsigned char *dllbase, *import_data, *import_name;
-	DWORD pe_offset, opt_offset;
-	WORD opt_magic;
-	int num_dict_off, import_off;
-
-	/* Safety check input */
-	if (hModule == NULL) {
-		return NULL;
-	}
-
-	/* Module instance is also the base load address.  First portion of
-	   memory is the MS-DOS loader, which holds the offset to the PE
-	   header (from the load base) at 0x3C */
-	dllbase = (unsigned char *)hModule;
-	pe_offset = DWORD_AT(dllbase + 0x3C);
-
-	/* The PE signature must be "PE\0\0" */
-	if (memcmp(dllbase+pe_offset,"PE\0\0",4)) {
-		return NULL;
-	}
-
-	/* Following the PE signature is the standard COFF header (20
-	   bytes) and then the optional header.  The optional header starts
-	   with a magic value of 0x10B for PE32 or 0x20B for PE32+ (PE32+
-	   uses 64-bits for some fields).  It might also be 0x107 for a ROM
-	   image, but we don't process that here.
-
-	   The optional header ends with a data dictionary that directly
-	   points to certain types of data, among them the import entries
-	   (in the second table entry). Based on the header type, we
-	   determine offsets for the data dictionary count and the entry
-	   within the dictionary pointing to the imports. */
-
-	opt_offset = pe_offset + 4 + 20;
-	opt_magic = WORD_AT(dllbase+opt_offset);
-	if (opt_magic == 0x10B) {
-		/* PE32 */
-		num_dict_off = 92;
-		import_off   = 104;
-	} else if (opt_magic == 0x20B) {
-		/* PE32+ */
-		num_dict_off = 108;
-		import_off   = 120;
-	} else {
-		/* Unsupported */
-		return NULL;
-	}
-
-	/* Now if an import table exists, offset to it and walk the list of
-	   imports.  The import table is an array (ending when an entry has
-	   empty values) of structures (20 bytes each), which contains (at
-	   offset 12) a relative address (to the module base) at which a
-	   string constant holding the import name is located. */
-
-	if (DWORD_AT(dllbase + opt_offset + num_dict_off) >= 2) {
-		/* We have at least 2 tables - the import table is the second
-		   one.  But still it may be that the table size is zero */
-		if (0 == DWORD_AT(dllbase + opt_offset + import_off + sizeof(DWORD)))
-			return NULL;
-		import_data = dllbase + DWORD_AT(dllbase +
-						 opt_offset +
-						 import_off);
-		while (DWORD_AT(import_data)) {
-			import_name = dllbase + DWORD_AT(import_data+12);
-			if (strlen(import_name) >= 6 &&
-			    !strncmp(import_name,"python",6)) {
-				char *pch;
-
-				/* Ensure python prefix is followed only
-				   by numbers to the end of the basename */
-				pch = import_name + 6;
+    unsigned char *dllbase, *import_data, *import_name;
+    DWORD pe_offset, opt_offset;
+    WORD opt_magic;
+    int num_dict_off, import_off;
+
+    /* Safety check input */
+    if (hModule == NULL) {
+        return NULL;
+    }
+
+    /* Module instance is also the base load address.  First portion of
+       memory is the MS-DOS loader, which holds the offset to the PE
+       header (from the load base) at 0x3C */
+    dllbase = (unsigned char *)hModule;
+    pe_offset = DWORD_AT(dllbase + 0x3C);
+
+    /* The PE signature must be "PE\0\0" */
+    if (memcmp(dllbase+pe_offset,"PE\0\0",4)) {
+        return NULL;
+    }
+
+    /* Following the PE signature is the standard COFF header (20
+       bytes) and then the optional header.  The optional header starts
+       with a magic value of 0x10B for PE32 or 0x20B for PE32+ (PE32+
+       uses 64-bits for some fields).  It might also be 0x107 for a ROM
+       image, but we don't process that here.
+
+       The optional header ends with a data dictionary that directly
+       points to certain types of data, among them the import entries
+       (in the second table entry). Based on the header type, we
+       determine offsets for the data dictionary count and the entry
+       within the dictionary pointing to the imports. */
+
+    opt_offset = pe_offset + 4 + 20;
+    opt_magic = WORD_AT(dllbase+opt_offset);
+    if (opt_magic == 0x10B) {
+        /* PE32 */
+        num_dict_off = 92;
+        import_off   = 104;
+    } else if (opt_magic == 0x20B) {
+        /* PE32+ */
+        num_dict_off = 108;
+        import_off   = 120;
+    } else {
+        /* Unsupported */
+        return NULL;
+    }
+
+    /* Now if an import table exists, offset to it and walk the list of
+       imports.  The import table is an array (ending when an entry has
+       empty values) of structures (20 bytes each), which contains (at
+       offset 12) a relative address (to the module base) at which a
+       string constant holding the import name is located. */
+
+    if (DWORD_AT(dllbase + opt_offset + num_dict_off) >= 2) {
+        /* We have at least 2 tables - the import table is the second
+           one.  But still it may be that the table size is zero */
+        if (0 == DWORD_AT(dllbase + opt_offset + import_off + sizeof(DWORD)))
+            return NULL;
+        import_data = dllbase + DWORD_AT(dllbase +
+                                         opt_offset +
+                                         import_off);
+        while (DWORD_AT(import_data)) {
+            import_name = dllbase + DWORD_AT(import_data+12);
+            if (strlen(import_name) >= 6 &&
+                !strncmp(import_name,"python",6)) {
+                char *pch;
+
+                /* Ensure python prefix is followed only
+                   by numbers to the end of the basename */
+                pch = import_name + 6;
 #ifdef _DEBUG
-				while (*pch && pch[0] != '_' && pch[1] != 'd' && pch[2] != '.') {
+                while (*pch && pch[0] != '_' && pch[1] != 'd' && pch[2] != '.') {
 #else
-				while (*pch && *pch != '.') {
+                while (*pch && *pch != '.') {
 #endif
-					if (*pch >= '0' && *pch <= '9') {
-						pch++;
-					} else {
-						pch = NULL;
-						break;
-					}
-				}
-	    
-				if (pch) {
-					/* Found it - return the name */
-					return import_name;
-				}
-			}
-			import_data += 20;
-		}
-	}
-
-	return NULL;
+                    if (*pch >= '0' && *pch <= '9') {
+                        pch++;
+                    } else {
+                        pch = NULL;
+                        break;
+                    }
+                }
+
+                if (pch) {
+                    /* Found it - return the name */
+                    return import_name;
+                }
+            }
+            import_data += 20;
+        }
+    }
+
+    return NULL;
 }
 
 
 dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
-				    const char *pathname, FILE *fp)
+                                    const char *pathname, FILE *fp)
 {
-	dl_funcptr p;
-	char funcname[258], *import_python;
-
-	PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
-
-	{
-		HINSTANCE hDLL = NULL;
-		char pathbuf[260];
-		LPTSTR dummy;
-		unsigned int old_mode;
-		ULONG_PTR cookie = 0;
-		/* We use LoadLibraryEx so Windows looks for dependent DLLs 
-		    in directory of pathname first.  However, Windows95
-		    can sometimes not work correctly unless the absolute
-		    path is used.  If GetFullPathName() fails, the LoadLibrary
-		    will certainly fail too, so use its error code */
-
-		/* Don't display a message box when Python can't load a DLL */
-		old_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
-
-		if (GetFullPathName(pathname,
-				    sizeof(pathbuf),
-				    pathbuf,
-				    &dummy)) {
-			ULONG_PTR cookie = _Py_ActivateActCtx();
-			/* XXX This call doesn't exist in Windows CE */
-			hDLL = LoadLibraryEx(pathname, NULL,
-					     LOAD_WITH_ALTERED_SEARCH_PATH);
-			_Py_DeactivateActCtx(cookie);
-		}
-
-		/* restore old error mode settings */
-		SetErrorMode(old_mode);
-
-		if (hDLL==NULL){
-			char errBuf[256];
-			unsigned int errorCode;
-
-			/* Get an error string from Win32 error code */
-			char theInfo[256]; /* Pointer to error text
-					      from system */
-			int theLength; /* Length of error text */
-
-			errorCode = GetLastError();
-
-			theLength = FormatMessage(
-				FORMAT_MESSAGE_FROM_SYSTEM |
-				FORMAT_MESSAGE_IGNORE_INSERTS, /* flags */
-				NULL, /* message source */
-				errorCode, /* the message (error) ID */
-				0, /* default language environment */
-				(LPTSTR) theInfo, /* the buffer */
-				sizeof(theInfo), /* the buffer size */
-				NULL); /* no additional format args. */
-
-			/* Problem: could not get the error message.
-			   This should not happen if called correctly. */
-			if (theLength == 0) {
-				PyOS_snprintf(errBuf, sizeof(errBuf),
-				      "DLL load failed with error code %d",
-					      errorCode);
-			} else {
-				size_t len;
-				/* For some reason a \r\n
-				   is appended to the text */
-				if (theLength >= 2 &&
-				    theInfo[theLength-2] == '\r' &&
-				    theInfo[theLength-1] == '\n') {
-					theLength -= 2;
-					theInfo[theLength] = '\0';
-				}
-				strcpy(errBuf, "DLL load failed: ");
-				len = strlen(errBuf);
-				strncpy(errBuf+len, theInfo,
-					sizeof(errBuf)-len);
-				errBuf[sizeof(errBuf)-1] = '\0';
-			}
-			PyErr_SetString(PyExc_ImportError, errBuf);
-			return NULL;
-		} else {
-			char buffer[256];
+    dl_funcptr p;
+    char funcname[258], *import_python;
+
+    PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
+
+    {
+        HINSTANCE hDLL = NULL;
+        char pathbuf[260];
+        LPTSTR dummy;
+        unsigned int old_mode;
+        ULONG_PTR cookie = 0;
+        /* We use LoadLibraryEx so Windows looks for dependent DLLs
+            in directory of pathname first.  However, Windows95
+            can sometimes not work correctly unless the absolute
+            path is used.  If GetFullPathName() fails, the LoadLibrary
+            will certainly fail too, so use its error code */
+
+        /* Don't display a message box when Python can't load a DLL */
+        old_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
+
+        if (GetFullPathName(pathname,
+                            sizeof(pathbuf),
+                            pathbuf,
+                            &dummy)) {
+            ULONG_PTR cookie = _Py_ActivateActCtx();
+            /* XXX This call doesn't exist in Windows CE */
+            hDLL = LoadLibraryEx(pathname, NULL,
+                                 LOAD_WITH_ALTERED_SEARCH_PATH);
+            _Py_DeactivateActCtx(cookie);
+        }
+
+        /* restore old error mode settings */
+        SetErrorMode(old_mode);
+
+        if (hDLL==NULL){
+            char errBuf[256];
+            unsigned int errorCode;
+
+            /* Get an error string from Win32 error code */
+            char theInfo[256]; /* Pointer to error text
+                                  from system */
+            int theLength; /* Length of error text */
+
+            errorCode = GetLastError();
+
+            theLength = FormatMessage(
+                FORMAT_MESSAGE_FROM_SYSTEM |
+                FORMAT_MESSAGE_IGNORE_INSERTS, /* flags */
+                NULL, /* message source */
+                errorCode, /* the message (error) ID */
+                0, /* default language environment */
+                (LPTSTR) theInfo, /* the buffer */
+                sizeof(theInfo), /* the buffer size */
+                NULL); /* no additional format args. */
+
+            /* Problem: could not get the error message.
+               This should not happen if called correctly. */
+            if (theLength == 0) {
+                PyOS_snprintf(errBuf, sizeof(errBuf),
+                      "DLL load failed with error code %d",
+                          errorCode);
+            } else {
+                size_t len;
+                /* For some reason a \r\n
+                   is appended to the text */
+                if (theLength >= 2 &&
+                    theInfo[theLength-2] == '\r' &&
+                    theInfo[theLength-1] == '\n') {
+                    theLength -= 2;
+                    theInfo[theLength] = '\0';
+                }
+                strcpy(errBuf, "DLL load failed: ");
+                len = strlen(errBuf);
+                strncpy(errBuf+len, theInfo,
+                    sizeof(errBuf)-len);
+                errBuf[sizeof(errBuf)-1] = '\0';
+            }
+            PyErr_SetString(PyExc_ImportError, errBuf);
+            return NULL;
+        } else {
+            char buffer[256];
 
 #ifdef _DEBUG
-			PyOS_snprintf(buffer, sizeof(buffer), "python%d%d_d.dll",
+            PyOS_snprintf(buffer, sizeof(buffer), "python%d%d_d.dll",
 #else
-			PyOS_snprintf(buffer, sizeof(buffer), "python%d%d.dll",
+            PyOS_snprintf(buffer, sizeof(buffer), "python%d%d.dll",
 #endif
-				      PY_MAJOR_VERSION,PY_MINOR_VERSION);
-			import_python = GetPythonImport(hDLL);
-
-			if (import_python &&
-			    strcasecmp(buffer,import_python)) {
-				PyOS_snprintf(buffer, sizeof(buffer),
-					      "Module use of %.150s conflicts "
-					      "with this version of Python.",
-					      import_python);
-				PyErr_SetString(PyExc_ImportError,buffer);
-				FreeLibrary(hDLL);
-				return NULL;
-			}
-		}
-		p = GetProcAddress(hDLL, funcname);
-	}
-
-	return p;
+                          PY_MAJOR_VERSION,PY_MINOR_VERSION);
+            import_python = GetPythonImport(hDLL);
+
+            if (import_python &&
+                strcasecmp(buffer,import_python)) {
+                PyOS_snprintf(buffer, sizeof(buffer),
+                              "Module use of %.150s conflicts "
+                              "with this version of Python.",
+                              import_python);
+                PyErr_SetString(PyExc_ImportError,buffer);
+                FreeLibrary(hDLL);
+                return NULL;
+            }
+        }
+        p = GetProcAddress(hDLL, funcname);
+    }
+
+    return p;
 }
diff --git a/Python/errors.c b/Python/errors.c
index 2d47779..4294f2f 100644
--- a/Python/errors.c
+++ b/Python/errors.c
@@ -24,115 +24,115 @@ extern "C" {
 void
 PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback)
 {
-	PyThreadState *tstate = PyThreadState_GET();
-	PyObject *oldtype, *oldvalue, *oldtraceback;
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *oldtype, *oldvalue, *oldtraceback;
 
-	if (traceback != NULL && !PyTraceBack_Check(traceback)) {
-		/* XXX Should never happen -- fatal error instead? */
-		/* Well, it could be None. */
-		Py_DECREF(traceback);
-		traceback = NULL;
-	}
+    if (traceback != NULL && !PyTraceBack_Check(traceback)) {
+        /* XXX Should never happen -- fatal error instead? */
+        /* Well, it could be None. */
+        Py_DECREF(traceback);
+        traceback = NULL;
+    }
 
-	/* Save these in locals to safeguard against recursive
-	   invocation through Py_XDECREF */
-	oldtype = tstate->curexc_type;
-	oldvalue = tstate->curexc_value;
-	oldtraceback = tstate->curexc_traceback;
+    /* Save these in locals to safeguard against recursive
+       invocation through Py_XDECREF */
+    oldtype = tstate->curexc_type;
+    oldvalue = tstate->curexc_value;
+    oldtraceback = tstate->curexc_traceback;
 
-	tstate->curexc_type = type;
-	tstate->curexc_value = value;
-	tstate->curexc_traceback = traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = traceback;
 
-	Py_XDECREF(oldtype);
-	Py_XDECREF(oldvalue);
-	Py_XDECREF(oldtraceback);
+    Py_XDECREF(oldtype);
+    Py_XDECREF(oldvalue);
+    Py_XDECREF(oldtraceback);
 }
 
 void
 PyErr_SetObject(PyObject *exception, PyObject *value)
 {
-	Py_XINCREF(exception);
-	Py_XINCREF(value);
-	PyErr_Restore(exception, value, (PyObject *)NULL);
+    Py_XINCREF(exception);
+    Py_XINCREF(value);
+    PyErr_Restore(exception, value, (PyObject *)NULL);
 }
 
 void
 PyErr_SetNone(PyObject *exception)
 {
-	PyErr_SetObject(exception, (PyObject *)NULL);
+    PyErr_SetObject(exception, (PyObject *)NULL);
 }
 
 void
 PyErr_SetString(PyObject *exception, const char *string)
 {
-	PyObject *value = PyString_FromString(string);
-	PyErr_SetObject(exception, value);
-	Py_XDECREF(value);
+    PyObject *value = PyString_FromString(string);
+    PyErr_SetObject(exception, value);
+    Py_XDECREF(value);
 }
 
 
 PyObject *
 PyErr_Occurred(void)
 {
-	PyThreadState *tstate = PyThreadState_GET();
+    PyThreadState *tstate = PyThreadState_GET();
 
-	return tstate->curexc_type;
+    return tstate->curexc_type;
 }
 
 
 int
 PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
 {
-	if (err == NULL || exc == NULL) {
-		/* maybe caused by "import exceptions" that failed early on */
-		return 0;
-	}
-	if (PyTuple_Check(exc)) {
-		Py_ssize_t i, n;
-		n = PyTuple_Size(exc);
-		for (i = 0; i < n; i++) {
-			/* Test recursively */
-		     if (PyErr_GivenExceptionMatches(
-			     err, PyTuple_GET_ITEM(exc, i)))
-		     {
-			     return 1;
-		     }
-		}
-		return 0;
-	}
-	/* err might be an instance, so check its class. */
-	if (PyExceptionInstance_Check(err))
-		err = PyExceptionInstance_Class(err);
-
-	if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
-		int res = 0, reclimit;
-		PyObject *exception, *value, *tb;
-		PyErr_Fetch(&exception, &value, &tb);
-		/* Temporarily bump the recursion limit, so that in the most
-		   common case PyObject_IsSubclass will not raise a recursion
-		   error we have to ignore anyway. */
-		reclimit = Py_GetRecursionLimit();
-		Py_SetRecursionLimit(reclimit + 5);
-		res = PyObject_IsSubclass(err, exc);
-		Py_SetRecursionLimit(reclimit);
-		/* This function must not fail, so print the error here */
-		if (res == -1) {
-			PyErr_WriteUnraisable(err);
-			res = 0;
-		}
-		PyErr_Restore(exception, value, tb);
-		return res;
-	}
-
-	return err == exc;
+    if (err == NULL || exc == NULL) {
+        /* maybe caused by "import exceptions" that failed early on */
+        return 0;
+    }
+    if (PyTuple_Check(exc)) {
+        Py_ssize_t i, n;
+        n = PyTuple_Size(exc);
+        for (i = 0; i < n; i++) {
+            /* Test recursively */
+             if (PyErr_GivenExceptionMatches(
+                 err, PyTuple_GET_ITEM(exc, i)))
+             {
+                 return 1;
+             }
+        }
+        return 0;
+    }
+    /* err might be an instance, so check its class. */
+    if (PyExceptionInstance_Check(err))
+        err = PyExceptionInstance_Class(err);
+
+    if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
+        int res = 0, reclimit;
+        PyObject *exception, *value, *tb;
+        PyErr_Fetch(&exception, &value, &tb);
+        /* Temporarily bump the recursion limit, so that in the most
+           common case PyObject_IsSubclass will not raise a recursion
+           error we have to ignore anyway. */
+        reclimit = Py_GetRecursionLimit();
+        Py_SetRecursionLimit(reclimit + 5);
+        res = PyObject_IsSubclass(err, exc);
+        Py_SetRecursionLimit(reclimit);
+        /* This function must not fail, so print the error here */
+        if (res == -1) {
+            PyErr_WriteUnraisable(err);
+            res = 0;
+        }
+        PyErr_Restore(exception, value, tb);
+        return res;
+    }
+
+    return err == exc;
 }
 
 
 int
 PyErr_ExceptionMatches(PyObject *exc)
 {
-	return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
+    return PyErr_GivenExceptionMatches(PyErr_Occurred(), exc);
 }
 
 
@@ -142,123 +142,123 @@ PyErr_ExceptionMatches(PyObject *exc)
 void
 PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb)
 {
-	PyObject *type = *exc;
-	PyObject *value = *val;
-	PyObject *inclass = NULL;
-	PyObject *initial_tb = NULL;
-	PyThreadState *tstate = NULL;
-
-	if (type == NULL) {
-		/* There was no exception, so nothing to do. */
-		return;
-	}
-
-	/* If PyErr_SetNone() was used, the value will have been actually
-	   set to NULL.
-	*/
-	if (!value) {
-		value = Py_None;
-		Py_INCREF(value);
-	}
-
-	if (PyExceptionInstance_Check(value))
-		inclass = PyExceptionInstance_Class(value);
-
-	/* Normalize the exception so that if the type is a class, the
-	   value will be an instance.
-	*/
-	if (PyExceptionClass_Check(type)) {
-		/* if the value was not an instance, or is not an instance
-		   whose class is (or is derived from) type, then use the
-		   value as an argument to instantiation of the type
-		   class.
-		*/
-		if (!inclass || !PyObject_IsSubclass(inclass, type)) {
-			PyObject *args, *res;
-
-			if (value == Py_None)
-				args = PyTuple_New(0);
-			else if (PyTuple_Check(value)) {
-				Py_INCREF(value);
-				args = value;
-			}
-			else
-				args = PyTuple_Pack(1, value);
-
-			if (args == NULL)
-				goto finally;
-			res = PyEval_CallObject(type, args);
-			Py_DECREF(args);
-			if (res == NULL)
-				goto finally;
-			Py_DECREF(value);
-			value = res;
-		}
-		/* if the class of the instance doesn't exactly match the
-		   class of the type, believe the instance
-		*/
-		else if (inclass != type) {
- 			Py_DECREF(type);
-			type = inclass;
-			Py_INCREF(type);
-		}
-	}
-	*exc = type;
-	*val = value;
-	return;
+    PyObject *type = *exc;
+    PyObject *value = *val;
+    PyObject *inclass = NULL;
+    PyObject *initial_tb = NULL;
+    PyThreadState *tstate = NULL;
+
+    if (type == NULL) {
+        /* There was no exception, so nothing to do. */
+        return;
+    }
+
+    /* If PyErr_SetNone() was used, the value will have been actually
+       set to NULL.
+    */
+    if (!value) {
+        value = Py_None;
+        Py_INCREF(value);
+    }
+
+    if (PyExceptionInstance_Check(value))
+        inclass = PyExceptionInstance_Class(value);
+
+    /* Normalize the exception so that if the type is a class, the
+       value will be an instance.
+    */
+    if (PyExceptionClass_Check(type)) {
+        /* if the value was not an instance, or is not an instance
+           whose class is (or is derived from) type, then use the
+           value as an argument to instantiation of the type
+           class.
+        */
+        if (!inclass || !PyObject_IsSubclass(inclass, type)) {
+            PyObject *args, *res;
+
+            if (value == Py_None)
+                args = PyTuple_New(0);
+            else if (PyTuple_Check(value)) {
+                Py_INCREF(value);
+                args = value;
+            }
+            else
+                args = PyTuple_Pack(1, value);
+
+            if (args == NULL)
+                goto finally;
+            res = PyEval_CallObject(type, args);
+            Py_DECREF(args);
+            if (res == NULL)
+                goto finally;
+            Py_DECREF(value);
+            value = res;
+        }
+        /* if the class of the instance doesn't exactly match the
+           class of the type, believe the instance
+        */
+        else if (inclass != type) {
+            Py_DECREF(type);
+            type = inclass;
+            Py_INCREF(type);
+        }
+    }
+    *exc = type;
+    *val = value;
+    return;
 finally:
-	Py_DECREF(type);
-	Py_DECREF(value);
-	/* If the new exception doesn't set a traceback and the old
-	   exception had a traceback, use the old traceback for the
-	   new exception.  It's better than nothing.
-	*/
-	initial_tb = *tb;
-	PyErr_Fetch(exc, val, tb);
-	if (initial_tb != NULL) {
-		if (*tb == NULL)
-			*tb = initial_tb;
-		else
-			Py_DECREF(initial_tb);
-	}
-	/* normalize recursively */
-	tstate = PyThreadState_GET();
-	if (++tstate->recursion_depth > Py_GetRecursionLimit()) {
-	    --tstate->recursion_depth;
-	    /* throw away the old exception... */
-	    Py_DECREF(*exc);
-	    Py_DECREF(*val);
-	    /* ... and use the recursion error instead */
-	    *exc = PyExc_RuntimeError;
-	    *val = PyExc_RecursionErrorInst;
-	    Py_INCREF(*exc);
-	    Py_INCREF(*val);
-	    /* just keeping the old traceback */
-	    return;
-	}
-	PyErr_NormalizeException(exc, val, tb);
-	--tstate->recursion_depth;
+    Py_DECREF(type);
+    Py_DECREF(value);
+    /* If the new exception doesn't set a traceback and the old
+       exception had a traceback, use the old traceback for the
+       new exception.  It's better than nothing.
+    */
+    initial_tb = *tb;
+    PyErr_Fetch(exc, val, tb);
+    if (initial_tb != NULL) {
+        if (*tb == NULL)
+            *tb = initial_tb;
+        else
+            Py_DECREF(initial_tb);
+    }
+    /* normalize recursively */
+    tstate = PyThreadState_GET();
+    if (++tstate->recursion_depth > Py_GetRecursionLimit()) {
+        --tstate->recursion_depth;
+        /* throw away the old exception... */
+        Py_DECREF(*exc);
+        Py_DECREF(*val);
+        /* ... and use the recursion error instead */
+        *exc = PyExc_RuntimeError;
+        *val = PyExc_RecursionErrorInst;
+        Py_INCREF(*exc);
+        Py_INCREF(*val);
+        /* just keeping the old traceback */
+        return;
+    }
+    PyErr_NormalizeException(exc, val, tb);
+    --tstate->recursion_depth;
 }
 
 
 void
 PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback)
 {
-	PyThreadState *tstate = PyThreadState_GET();
+    PyThreadState *tstate = PyThreadState_GET();
 
-	*p_type = tstate->curexc_type;
-	*p_value = tstate->curexc_value;
-	*p_traceback = tstate->curexc_traceback;
+    *p_type = tstate->curexc_type;
+    *p_value = tstate->curexc_value;
+    *p_traceback = tstate->curexc_traceback;
 
-	tstate->curexc_type = NULL;
-	tstate->curexc_value = NULL;
-	tstate->curexc_traceback = NULL;
+    tstate->curexc_type = NULL;
+    tstate->curexc_value = NULL;
+    tstate->curexc_traceback = NULL;
 }
 
 void
 PyErr_Clear(void)
 {
-	PyErr_Restore(NULL, NULL, NULL);
+    PyErr_Restore(NULL, NULL, NULL);
 }
 
 /* Convenience functions to set a type error exception and return 0 */
@@ -266,258 +266,258 @@ PyErr_Clear(void)
 int
 PyErr_BadArgument(void)
 {
-	PyErr_SetString(PyExc_TypeError,
-			"bad argument type for built-in operation");
-	return 0;
+    PyErr_SetString(PyExc_TypeError,
+                    "bad argument type for built-in operation");
+    return 0;
 }
 
 PyObject *
 PyErr_NoMemory(void)
 {
-	if (PyErr_ExceptionMatches(PyExc_MemoryError))
-		/* already current */
-		return NULL;
+    if (PyErr_ExceptionMatches(PyExc_MemoryError))
+        /* already current */
+        return NULL;
 
-	/* raise the pre-allocated instance if it still exists */
-	if (PyExc_MemoryErrorInst)
-		PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
-	else
-		/* this will probably fail since there's no memory and hee,
-		   hee, we have to instantiate this class
-		*/
-		PyErr_SetNone(PyExc_MemoryError);
+    /* raise the pre-allocated instance if it still exists */
+    if (PyExc_MemoryErrorInst)
+        PyErr_SetObject(PyExc_MemoryError, PyExc_MemoryErrorInst);
+    else
+        /* this will probably fail since there's no memory and hee,
+           hee, we have to instantiate this class
+        */
+        PyErr_SetNone(PyExc_MemoryError);
 
-	return NULL;
+    return NULL;
 }
 
 PyObject *
 PyErr_SetFromErrnoWithFilenameObject(PyObject *exc, PyObject *filenameObject)
 {
-	PyObject *v;
-	char *s;
-	int i = errno;
+    PyObject *v;
+    char *s;
+    int i = errno;
 #ifdef PLAN9
-	char errbuf[ERRMAX];
+    char errbuf[ERRMAX];
 #endif
 #ifdef MS_WINDOWS
-	char *s_buf = NULL;
-	char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */
+    char *s_buf = NULL;
+    char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */
 #endif
 #ifdef EINTR
-	if (i == EINTR && PyErr_CheckSignals())
-		return NULL;
+    if (i == EINTR && PyErr_CheckSignals())
+        return NULL;
 #endif
 #ifdef PLAN9
-	rerrstr(errbuf, sizeof errbuf);
-	s = errbuf;
+    rerrstr(errbuf, sizeof errbuf);
+    s = errbuf;
 #else
-	if (i == 0)
-		s = "Error"; /* Sometimes errno didn't get set */
-	else
+    if (i == 0)
+        s = "Error"; /* Sometimes errno didn't get set */
+    else
 #ifndef MS_WINDOWS
-		s = strerror(i);
+        s = strerror(i);
 #else
-	{
-		/* Note that the Win32 errors do not lineup with the
-		   errno error.  So if the error is in the MSVC error
-		   table, we use it, otherwise we assume it really _is_
-		   a Win32 error code
-		*/
-		if (i > 0 && i < _sys_nerr) {
-			s = _sys_errlist[i];
-		}
-		else {
-			int len = FormatMessage(
-				FORMAT_MESSAGE_ALLOCATE_BUFFER |
-				FORMAT_MESSAGE_FROM_SYSTEM |
-				FORMAT_MESSAGE_IGNORE_INSERTS,
-				NULL,	/* no message source */
-				i,
-				MAKELANGID(LANG_NEUTRAL,
-					   SUBLANG_DEFAULT),
-				           /* Default language */
-				(LPTSTR) &s_buf,
-				0,	/* size not used */
-				NULL);	/* no args */
-			if (len==0) {
-				/* Only ever seen this in out-of-mem
-				   situations */
-				sprintf(s_small_buf, "Windows Error 0x%X", i);
-				s = s_small_buf;
-				s_buf = NULL;
-			} else {
-				s = s_buf;
-				/* remove trailing cr/lf and dots */
-				while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
-					s[--len] = '\0';
-			}
-		}
-	}
+    {
+        /* Note that the Win32 errors do not lineup with the
+           errno error.  So if the error is in the MSVC error
+           table, we use it, otherwise we assume it really _is_
+           a Win32 error code
+        */
+        if (i > 0 && i < _sys_nerr) {
+            s = _sys_errlist[i];
+        }
+        else {
+            int len = FormatMessage(
+                FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                FORMAT_MESSAGE_FROM_SYSTEM |
+                FORMAT_MESSAGE_IGNORE_INSERTS,
+                NULL,                   /* no message source */
+                i,
+                MAKELANGID(LANG_NEUTRAL,
+                           SUBLANG_DEFAULT),
+                           /* Default language */
+                (LPTSTR) &s_buf,
+                0,                      /* size not used */
+                NULL);                  /* no args */
+            if (len==0) {
+                /* Only ever seen this in out-of-mem
+                   situations */
+                sprintf(s_small_buf, "Windows Error 0x%X", i);
+                s = s_small_buf;
+                s_buf = NULL;
+            } else {
+                s = s_buf;
+                /* remove trailing cr/lf and dots */
+                while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
+                    s[--len] = '\0';
+            }
+        }
+    }
 #endif /* Unix/Windows */
 #endif /* PLAN 9*/
-	if (filenameObject != NULL)
-		v = Py_BuildValue("(isO)", i, s, filenameObject);
-	else
-		v = Py_BuildValue("(is)", i, s);
-	if (v != NULL) {
-		PyErr_SetObject(exc, v);
-		Py_DECREF(v);
-	}
+    if (filenameObject != NULL)
+        v = Py_BuildValue("(isO)", i, s, filenameObject);
+    else
+        v = Py_BuildValue("(is)", i, s);
+    if (v != NULL) {
+        PyErr_SetObject(exc, v);
+        Py_DECREF(v);
+    }
 #ifdef MS_WINDOWS
-	LocalFree(s_buf);
+    LocalFree(s_buf);
 #endif
-	return NULL;
+    return NULL;
 }
 
 
 PyObject *
 PyErr_SetFromErrnoWithFilename(PyObject *exc, const char *filename)
 {
-	PyObject *name = filename ? PyString_FromString(filename) : NULL;
-	PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
-	Py_XDECREF(name);
-	return result;
+    PyObject *name = filename ? PyString_FromString(filename) : NULL;
+    PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
+    Py_XDECREF(name);
+    return result;
 }
 
 #ifdef MS_WINDOWS
 PyObject *
 PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, const Py_UNICODE *filename)
 {
-	PyObject *name = filename ?
-	                 PyUnicode_FromUnicode(filename, wcslen(filename)) :
-	                 NULL;
-	PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
-	Py_XDECREF(name);
-	return result;
+    PyObject *name = filename ?
+                     PyUnicode_FromUnicode(filename, wcslen(filename)) :
+             NULL;
+    PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name);
+    Py_XDECREF(name);
+    return result;
 }
 #endif /* MS_WINDOWS */
 
 PyObject *
 PyErr_SetFromErrno(PyObject *exc)
 {
-	return PyErr_SetFromErrnoWithFilenameObject(exc, NULL);
+    return PyErr_SetFromErrnoWithFilenameObject(exc, NULL);
 }
 
 #ifdef MS_WINDOWS
 /* Windows specific error code handling */
 PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject(
-	PyObject *exc,
-	int ierr,
-	PyObject *filenameObject)
+    PyObject *exc,
+    int ierr,
+    PyObject *filenameObject)
 {
-	int len;
-	char *s;
-	char *s_buf = NULL; /* Free via LocalFree */
-	char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */
-	PyObject *v;
-	DWORD err = (DWORD)ierr;
-	if (err==0) err = GetLastError();
-	len = FormatMessage(
-		/* Error API error */
-		FORMAT_MESSAGE_ALLOCATE_BUFFER |
-		FORMAT_MESSAGE_FROM_SYSTEM |
-		FORMAT_MESSAGE_IGNORE_INSERTS,
-		NULL,	/* no message source */
-		err,
-		MAKELANGID(LANG_NEUTRAL,
-		SUBLANG_DEFAULT), /* Default language */
-		(LPTSTR) &s_buf,
-		0,	/* size not used */
-		NULL);	/* no args */
-	if (len==0) {
-		/* Only seen this in out of mem situations */
-		sprintf(s_small_buf, "Windows Error 0x%X", err);
-		s = s_small_buf;
-		s_buf = NULL;
-	} else {
-		s = s_buf;
-		/* remove trailing cr/lf and dots */
-		while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
-			s[--len] = '\0';
-	}
-	if (filenameObject != NULL)
-		v = Py_BuildValue("(isO)", err, s, filenameObject);
-	else
-		v = Py_BuildValue("(is)", err, s);
-	if (v != NULL) {
-		PyErr_SetObject(exc, v);
-		Py_DECREF(v);
-	}
-	LocalFree(s_buf);
-	return NULL;
+    int len;
+    char *s;
+    char *s_buf = NULL; /* Free via LocalFree */
+    char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */
+    PyObject *v;
+    DWORD err = (DWORD)ierr;
+    if (err==0) err = GetLastError();
+    len = FormatMessage(
+        /* Error API error */
+        FORMAT_MESSAGE_ALLOCATE_BUFFER |
+        FORMAT_MESSAGE_FROM_SYSTEM |
+        FORMAT_MESSAGE_IGNORE_INSERTS,
+        NULL,           /* no message source */
+        err,
+        MAKELANGID(LANG_NEUTRAL,
+        SUBLANG_DEFAULT), /* Default language */
+        (LPTSTR) &s_buf,
+        0,              /* size not used */
+        NULL);          /* no args */
+    if (len==0) {
+        /* Only seen this in out of mem situations */
+        sprintf(s_small_buf, "Windows Error 0x%X", err);
+        s = s_small_buf;
+        s_buf = NULL;
+    } else {
+        s = s_buf;
+        /* remove trailing cr/lf and dots */
+        while (len > 0 && (s[len-1] <= ' ' || s[len-1] == '.'))
+            s[--len] = '\0';
+    }
+    if (filenameObject != NULL)
+        v = Py_BuildValue("(isO)", err, s, filenameObject);
+    else
+        v = Py_BuildValue("(is)", err, s);
+    if (v != NULL) {
+        PyErr_SetObject(exc, v);
+        Py_DECREF(v);
+    }
+    LocalFree(s_buf);
+    return NULL;
 }
 
 PyObject *PyErr_SetExcFromWindowsErrWithFilename(
-	PyObject *exc,
-	int ierr,
-	const char *filename)
+    PyObject *exc,
+    int ierr,
+    const char *filename)
 {
-	PyObject *name = filename ? PyString_FromString(filename) : NULL;
-	PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
-	                                                             ierr,
-	                                                             name);
-	Py_XDECREF(name);
-	return ret;
+    PyObject *name = filename ? PyString_FromString(filename) : NULL;
+    PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
+                                                                 ierr,
+                                                                 name);
+    Py_XDECREF(name);
+    return ret;
 }
 
 PyObject *PyErr_SetExcFromWindowsErrWithUnicodeFilename(
-	PyObject *exc,
-	int ierr,
-	const Py_UNICODE *filename)
+    PyObject *exc,
+    int ierr,
+    const Py_UNICODE *filename)
 {
-	PyObject *name = filename ?
-	                 PyUnicode_FromUnicode(filename, wcslen(filename)) :
-	                 NULL;
-	PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
-	                                                             ierr,
-	                                                             name);
-	Py_XDECREF(name);
-	return ret;
+    PyObject *name = filename ?
+                     PyUnicode_FromUnicode(filename, wcslen(filename)) :
+             NULL;
+    PyObject *ret = PyErr_SetExcFromWindowsErrWithFilenameObject(exc,
+                                                                 ierr,
+                                                                 name);
+    Py_XDECREF(name);
+    return ret;
 }
 
 PyObject *PyErr_SetExcFromWindowsErr(PyObject *exc, int ierr)
 {
-	return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL);
+    return PyErr_SetExcFromWindowsErrWithFilename(exc, ierr, NULL);
 }
 
 PyObject *PyErr_SetFromWindowsErr(int ierr)
 {
-	return PyErr_SetExcFromWindowsErrWithFilename(PyExc_WindowsError,
-						      ierr, NULL);
+    return PyErr_SetExcFromWindowsErrWithFilename(PyExc_WindowsError,
+                                                  ierr, NULL);
 }
 PyObject *PyErr_SetFromWindowsErrWithFilename(
-	int ierr,
-	const char *filename)
+    int ierr,
+    const char *filename)
 {
-	PyObject *name = filename ? PyString_FromString(filename) : NULL;
-	PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
-						      PyExc_WindowsError,
-						      ierr, name);
-	Py_XDECREF(name);
-	return result;
+    PyObject *name = filename ? PyString_FromString(filename) : NULL;
+    PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
+                                                  PyExc_WindowsError,
+                                                  ierr, name);
+    Py_XDECREF(name);
+    return result;
 }
 
 PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename(
-	int ierr,
-	const Py_UNICODE *filename)
+    int ierr,
+    const Py_UNICODE *filename)
 {
-	PyObject *name = filename ?
-	                 PyUnicode_FromUnicode(filename, wcslen(filename)) :
-	                 NULL;
-	PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
-						      PyExc_WindowsError,
-						      ierr, name);
-	Py_XDECREF(name);
-	return result;
+    PyObject *name = filename ?
+                     PyUnicode_FromUnicode(filename, wcslen(filename)) :
+             NULL;
+    PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject(
+                                                  PyExc_WindowsError,
+                                                  ierr, name);
+    Py_XDECREF(name);
+    return result;
 }
 #endif /* MS_WINDOWS */
 
 void
 _PyErr_BadInternalCall(char *filename, int lineno)
 {
-	PyErr_Format(PyExc_SystemError,
-		     "%s:%d: bad argument to internal function",
-		     filename, lineno);
+    PyErr_Format(PyExc_SystemError,
+                 "%s:%d: bad argument to internal function",
+                 filename, lineno);
 }
 
 /* Remove the preprocessor macro for PyErr_BadInternalCall() so that we can
@@ -526,8 +526,8 @@ _PyErr_BadInternalCall(char *filename, int lineno)
 void
 PyErr_BadInternalCall(void)
 {
-	PyErr_Format(PyExc_SystemError,
-		     "bad argument to internal function");
+    PyErr_Format(PyExc_SystemError,
+                 "bad argument to internal function");
 }
 #define PyErr_BadInternalCall() _PyErr_BadInternalCall(__FILE__, __LINE__)
 
@@ -536,20 +536,20 @@ PyErr_BadInternalCall(void)
 PyObject *
 PyErr_Format(PyObject *exception, const char *format, ...)
 {
-	va_list vargs;
-	PyObject* string;
+    va_list vargs;
+    PyObject* string;
 
 #ifdef HAVE_STDARG_PROTOTYPES
-	va_start(vargs, format);
+    va_start(vargs, format);
 #else
-	va_start(vargs);
+    va_start(vargs);
 #endif
 
-	string = PyString_FromFormatV(format, vargs);
-	PyErr_SetObject(exception, string);
-	Py_XDECREF(string);
-	va_end(vargs);
-	return NULL;
+    string = PyString_FromFormatV(format, vargs);
+    PyErr_SetObject(exception, string);
+    Py_XDECREF(string);
+    va_end(vargs);
+    return NULL;
 }
 
 
@@ -557,51 +557,51 @@ PyErr_Format(PyObject *exception, const char *format, ...)
 PyObject *
 PyErr_NewException(char *name, PyObject *base, PyObject *dict)
 {
-	char *dot;
-	PyObject *modulename = NULL;
-	PyObject *classname = NULL;
-	PyObject *mydict = NULL;
-	PyObject *bases = NULL;
-	PyObject *result = NULL;
-	dot = strrchr(name, '.');
-	if (dot == NULL) {
-		PyErr_SetString(PyExc_SystemError,
-			"PyErr_NewException: name must be module.class");
-		return NULL;
-	}
-	if (base == NULL)
-		base = PyExc_Exception;
-	if (dict == NULL) {
-		dict = mydict = PyDict_New();
-		if (dict == NULL)
-			goto failure;
-	}
-	if (PyDict_GetItemString(dict, "__module__") == NULL) {
-		modulename = PyString_FromStringAndSize(name,
-						     (Py_ssize_t)(dot-name));
-		if (modulename == NULL)
-			goto failure;
-		if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
-			goto failure;
-	}
-	if (PyTuple_Check(base)) {
-		bases = base;
-		/* INCREF as we create a new ref in the else branch */
-		Py_INCREF(bases);
-	} else {
-		bases = PyTuple_Pack(1, base);
-		if (bases == NULL)
-			goto failure;
-	}
-	/* Create a real new-style class. */
-	result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO",
-				       dot+1, bases, dict);
+    char *dot;
+    PyObject *modulename = NULL;
+    PyObject *classname = NULL;
+    PyObject *mydict = NULL;
+    PyObject *bases = NULL;
+    PyObject *result = NULL;
+    dot = strrchr(name, '.');
+    if (dot == NULL) {
+        PyErr_SetString(PyExc_SystemError,
+            "PyErr_NewException: name must be module.class");
+        return NULL;
+    }
+    if (base == NULL)
+        base = PyExc_Exception;
+    if (dict == NULL) {
+        dict = mydict = PyDict_New();
+        if (dict == NULL)
+            goto failure;
+    }
+    if (PyDict_GetItemString(dict, "__module__") == NULL) {
+        modulename = PyString_FromStringAndSize(name,
+                                             (Py_ssize_t)(dot-name));
+        if (modulename == NULL)
+            goto failure;
+        if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
+            goto failure;
+    }
+    if (PyTuple_Check(base)) {
+        bases = base;
+        /* INCREF as we create a new ref in the else branch */
+        Py_INCREF(bases);
+    } else {
+        bases = PyTuple_Pack(1, base);
+        if (bases == NULL)
+            goto failure;
+    }
+    /* Create a real new-style class. */
+    result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO",
+                                   dot+1, bases, dict);
   failure:
-	Py_XDECREF(bases);
-	Py_XDECREF(mydict);
-	Py_XDECREF(classname);
-	Py_XDECREF(modulename);
-	return result;
+    Py_XDECREF(bases);
+    Py_XDECREF(mydict);
+    Py_XDECREF(classname);
+    Py_XDECREF(modulename);
+    return result;
 }
 
 
@@ -609,32 +609,32 @@ PyErr_NewException(char *name, PyObject *base, PyObject *dict)
 PyObject *
 PyErr_NewExceptionWithDoc(char *name, char *doc, PyObject *base, PyObject *dict)
 {
-	int result;
-	PyObject *ret = NULL;
-	PyObject *mydict = NULL; /* points to the dict only if we create it */
-	PyObject *docobj;
-
-	if (dict == NULL) {
-		dict = mydict = PyDict_New();
-		if (dict == NULL) {
-			return NULL;
-		}
-	}
-
-	if (doc != NULL) {
-		docobj = PyString_FromString(doc);
-		if (docobj == NULL)
-			goto failure;
-		result = PyDict_SetItemString(dict, "__doc__", docobj);
-		Py_DECREF(docobj);
-		if (result < 0)
-			goto failure;
-	}
-
-	ret = PyErr_NewException(name, base, dict);
+    int result;
+    PyObject *ret = NULL;
+    PyObject *mydict = NULL; /* points to the dict only if we create it */
+    PyObject *docobj;
+
+    if (dict == NULL) {
+        dict = mydict = PyDict_New();
+        if (dict == NULL) {
+            return NULL;
+        }
+    }
+
+    if (doc != NULL) {
+        docobj = PyString_FromString(doc);
+        if (docobj == NULL)
+            goto failure;
+        result = PyDict_SetItemString(dict, "__doc__", docobj);
+        Py_DECREF(docobj);
+        if (result < 0)
+            goto failure;
+    }
+
+    ret = PyErr_NewException(name, base, dict);
   failure:
-	Py_XDECREF(mydict);
-	return ret;
+    Py_XDECREF(mydict);
+    return ret;
 }
 
 
@@ -643,52 +643,52 @@ PyErr_NewExceptionWithDoc(char *name, char *doc, PyObject *base, PyObject *dict)
 void
 PyErr_WriteUnraisable(PyObject *obj)
 {
-	PyObject *f, *t, *v, *tb;
-	PyErr_Fetch(&t, &v, &tb);
-	f = PySys_GetObject("stderr");
-	if (f != NULL) {
-		PyFile_WriteString("Exception ", f);
-		if (t) {
-			PyObject* moduleName;
-			char* className;
-			assert(PyExceptionClass_Check(t));
-			className = PyExceptionClass_Name(t);
-			if (className != NULL) {
-				char *dot = strrchr(className, '.');
-				if (dot != NULL)
-					className = dot+1;
-			}
-
-			moduleName = PyObject_GetAttrString(t, "__module__");
-			if (moduleName == NULL)
-				PyFile_WriteString("<unknown>", f);
-			else {
-				char* modstr = PyString_AsString(moduleName);
-				if (modstr &&
-				    strcmp(modstr, "exceptions") != 0)
-				{
-					PyFile_WriteString(modstr, f);
-					PyFile_WriteString(".", f);
-				}
-			}
-			if (className == NULL)
-				PyFile_WriteString("<unknown>", f);
-			else
-				PyFile_WriteString(className, f);
-			if (v && v != Py_None) {
-				PyFile_WriteString(": ", f);
-				PyFile_WriteObject(v, f, 0);
-			}
-			Py_XDECREF(moduleName);
-		}
-		PyFile_WriteString(" in ", f);
-		PyFile_WriteObject(obj, f, 0);
-		PyFile_WriteString(" ignored\n", f);
-		PyErr_Clear(); /* Just in case */
-	}
-	Py_XDECREF(t);
-	Py_XDECREF(v);
-	Py_XDECREF(tb);
+    PyObject *f, *t, *v, *tb;
+    PyErr_Fetch(&t, &v, &tb);
+    f = PySys_GetObject("stderr");
+    if (f != NULL) {
+        PyFile_WriteString("Exception ", f);
+        if (t) {
+            PyObject* moduleName;
+            char* className;
+            assert(PyExceptionClass_Check(t));
+            className = PyExceptionClass_Name(t);
+            if (className != NULL) {
+                char *dot = strrchr(className, '.');
+                if (dot != NULL)
+                    className = dot+1;
+            }
+
+            moduleName = PyObject_GetAttrString(t, "__module__");
+            if (moduleName == NULL)
+                PyFile_WriteString("<unknown>", f);
+            else {
+                char* modstr = PyString_AsString(moduleName);
+                if (modstr &&
+                    strcmp(modstr, "exceptions") != 0)
+                {
+                    PyFile_WriteString(modstr, f);
+                    PyFile_WriteString(".", f);
+                }
+            }
+            if (className == NULL)
+                PyFile_WriteString("<unknown>", f);
+            else
+                PyFile_WriteString(className, f);
+            if (v && v != Py_None) {
+                PyFile_WriteString(": ", f);
+                PyFile_WriteObject(v, f, 0);
+            }
+            Py_XDECREF(moduleName);
+        }
+        PyFile_WriteString(" in ", f);
+        PyFile_WriteObject(obj, f, 0);
+        PyFile_WriteString(" ignored\n", f);
+        PyErr_Clear(); /* Just in case */
+    }
+    Py_XDECREF(t);
+    Py_XDECREF(v);
+    Py_XDECREF(tb);
 }
 
 extern PyObject *PyModule_GetWarningsModule(void);
@@ -701,59 +701,59 @@ extern PyObject *PyModule_GetWarningsModule(void);
 void
 PyErr_SyntaxLocation(const char *filename, int lineno)
 {
-	PyObject *exc, *v, *tb, *tmp;
-
-	/* add attributes for the line number and filename for the error */
-	PyErr_Fetch(&exc, &v, &tb);
-	PyErr_NormalizeException(&exc, &v, &tb);
-	/* XXX check that it is, indeed, a syntax error. It might not
-	 * be, though. */
-	tmp = PyInt_FromLong(lineno);
-	if (tmp == NULL)
-		PyErr_Clear();
-	else {
-		if (PyObject_SetAttrString(v, "lineno", tmp))
-			PyErr_Clear();
-		Py_DECREF(tmp);
-	}
-	if (filename != NULL) {
-		tmp = PyString_FromString(filename);
-		if (tmp == NULL)
-			PyErr_Clear();
-		else {
-			if (PyObject_SetAttrString(v, "filename", tmp))
-				PyErr_Clear();
-			Py_DECREF(tmp);
-		}
-
-		tmp = PyErr_ProgramText(filename, lineno);
-		if (tmp) {
-			if (PyObject_SetAttrString(v, "text", tmp))
-				PyErr_Clear();
-			Py_DECREF(tmp);
-		}
-	}
-	if (PyObject_SetAttrString(v, "offset", Py_None)) {
-		PyErr_Clear();
-	}
-	if (exc != PyExc_SyntaxError) {
-		if (!PyObject_HasAttrString(v, "msg")) {
-			tmp = PyObject_Str(v);
-			if (tmp) {
-				if (PyObject_SetAttrString(v, "msg", tmp))
-					PyErr_Clear();
-				Py_DECREF(tmp);
-			} else {
-				PyErr_Clear();
-			}
-		}
-		if (!PyObject_HasAttrString(v, "print_file_and_line")) {
-			if (PyObject_SetAttrString(v, "print_file_and_line",
-						   Py_None))
-				PyErr_Clear();
-		}
-	}
-	PyErr_Restore(exc, v, tb);
+    PyObject *exc, *v, *tb, *tmp;
+
+    /* add attributes for the line number and filename for the error */
+    PyErr_Fetch(&exc, &v, &tb);
+    PyErr_NormalizeException(&exc, &v, &tb);
+    /* XXX check that it is, indeed, a syntax error. It might not
+     * be, though. */
+    tmp = PyInt_FromLong(lineno);
+    if (tmp == NULL)
+        PyErr_Clear();
+    else {
+        if (PyObject_SetAttrString(v, "lineno", tmp))
+            PyErr_Clear();
+        Py_DECREF(tmp);
+    }
+    if (filename != NULL) {
+        tmp = PyString_FromString(filename);
+        if (tmp == NULL)
+            PyErr_Clear();
+        else {
+            if (PyObject_SetAttrString(v, "filename", tmp))
+                PyErr_Clear();
+            Py_DECREF(tmp);
+        }
+
+        tmp = PyErr_ProgramText(filename, lineno);
+        if (tmp) {
+            if (PyObject_SetAttrString(v, "text", tmp))
+                PyErr_Clear();
+            Py_DECREF(tmp);
+        }
+    }
+    if (PyObject_SetAttrString(v, "offset", Py_None)) {
+        PyErr_Clear();
+    }
+    if (exc != PyExc_SyntaxError) {
+        if (!PyObject_HasAttrString(v, "msg")) {
+            tmp = PyObject_Str(v);
+            if (tmp) {
+                if (PyObject_SetAttrString(v, "msg", tmp))
+                    PyErr_Clear();
+                Py_DECREF(tmp);
+            } else {
+                PyErr_Clear();
+            }
+        }
+        if (!PyObject_HasAttrString(v, "print_file_and_line")) {
+            if (PyObject_SetAttrString(v, "print_file_and_line",
+                                       Py_None))
+                PyErr_Clear();
+        }
+    }
+    PyErr_Restore(exc, v, tb);
 }
 
 /* com_fetch_program_text will attempt to load the line of text that
@@ -767,36 +767,36 @@ PyErr_SyntaxLocation(const char *filename, int lineno)
 PyObject *
 PyErr_ProgramText(const char *filename, int lineno)
 {
-	FILE *fp;
-	int i;
-	char linebuf[1000];
-
-	if (filename == NULL || *filename == '\0' || lineno <= 0)
-		return NULL;
-	fp = fopen(filename, "r" PY_STDIOTEXTMODE);
-	if (fp == NULL)
-		return NULL;
-	for (i = 0; i < lineno; i++) {
-		char *pLastChar = &linebuf[sizeof(linebuf) - 2];
-		do {
-			*pLastChar = '\0';
-			if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, fp, NULL) == NULL)
-				break;
-			/* fgets read *something*; if it didn't get as
-			   far as pLastChar, it must have found a newline
-			   or hit the end of the file; if pLastChar is \n,
-			   it obviously found a newline; else we haven't
-			   yet seen a newline, so must continue */
-		} while (*pLastChar != '\0' && *pLastChar != '\n');
-	}
-	fclose(fp);
-	if (i == lineno) {
-		char *p = linebuf;
-		while (*p == ' ' || *p == '\t' || *p == '\014')
-			p++;
-		return PyString_FromString(p);
-	}
-	return NULL;
+    FILE *fp;
+    int i;
+    char linebuf[1000];
+
+    if (filename == NULL || *filename == '\0' || lineno <= 0)
+        return NULL;
+    fp = fopen(filename, "r" PY_STDIOTEXTMODE);
+    if (fp == NULL)
+        return NULL;
+    for (i = 0; i < lineno; i++) {
+        char *pLastChar = &linebuf[sizeof(linebuf) - 2];
+        do {
+            *pLastChar = '\0';
+            if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, fp, NULL) == NULL)
+                break;
+            /* fgets read *something*; if it didn't get as
+               far as pLastChar, it must have found a newline
+               or hit the end of the file; if pLastChar is \n,
+               it obviously found a newline; else we haven't
+               yet seen a newline, so must continue */
+        } while (*pLastChar != '\0' && *pLastChar != '\n');
+    }
+    fclose(fp);
+    if (i == lineno) {
+        char *p = linebuf;
+        while (*p == ' ' || *p == '\t' || *p == '\014')
+            p++;
+        return PyString_FromString(p);
+    }
+    return NULL;
 }
 
 #ifdef __cplusplus
diff --git a/Python/frozen.c b/Python/frozen.c
index 946d626..ae7e9a4 100644
--- a/Python/frozen.c
+++ b/Python/frozen.c
@@ -12,24 +12,24 @@
    the appropriate bytes from M___main__.c. */
 
 static unsigned char M___hello__[] = {
-	99,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
-	0,115,9,0,0,0,100,0,0,71,72,100,1,0,83,40,
-	2,0,0,0,115,14,0,0,0,72,101,108,108,111,32,119,
-	111,114,108,100,46,46,46,78,40,0,0,0,0,40,0,0,
-	0,0,40,0,0,0,0,40,0,0,0,0,115,8,0,0,
-	0,104,101,108,108,111,46,112,121,115,1,0,0,0,63,1,
-	0,0,0,115,0,0,0,0,
+    99,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
+    0,115,9,0,0,0,100,0,0,71,72,100,1,0,83,40,
+    2,0,0,0,115,14,0,0,0,72,101,108,108,111,32,119,
+    111,114,108,100,46,46,46,78,40,0,0,0,0,40,0,0,
+    0,0,40,0,0,0,0,40,0,0,0,0,115,8,0,0,
+    0,104,101,108,108,111,46,112,121,115,1,0,0,0,63,1,
+    0,0,0,115,0,0,0,0,
 };
 
 #define SIZE (int)sizeof(M___hello__)
 
 static struct _frozen _PyImport_FrozenModules[] = {
-	/* Test module */
-	{"__hello__", M___hello__, SIZE},
-	/* Test package (negative size indicates package-ness) */
-	{"__phello__", M___hello__, -SIZE},
-	{"__phello__.spam", M___hello__, SIZE},
-	{0, 0, 0} /* sentinel */
+    /* Test module */
+    {"__hello__", M___hello__, SIZE},
+    /* Test package (negative size indicates package-ness) */
+    {"__phello__", M___hello__, -SIZE},
+    {"__phello__.spam", M___hello__, SIZE},
+    {0, 0, 0} /* sentinel */
 };
 
 /* Embedding apps may change this pointer to point to their favorite
diff --git a/Python/frozenmain.c b/Python/frozenmain.c
index 397f046..d31da07 100644
--- a/Python/frozenmain.c
+++ b/Python/frozenmain.c
@@ -14,55 +14,55 @@ extern int PyInitFrozenExtensions(void);
 int
 Py_FrozenMain(int argc, char **argv)
 {
-	char *p;
-	int n, sts;
-	int inspect = 0;
-	int unbuffered = 0;
+    char *p;
+    int n, sts;
+    int inspect = 0;
+    int unbuffered = 0;
 
-	Py_FrozenFlag = 1; /* Suppress errors from getpath.c */
+    Py_FrozenFlag = 1; /* Suppress errors from getpath.c */
 
-	if ((p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
-		inspect = 1;
-	if ((p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0')
-		unbuffered = 1;
+    if ((p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
+        inspect = 1;
+    if ((p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0')
+        unbuffered = 1;
 
-	if (unbuffered) {
-		setbuf(stdin, (char *)NULL);
-		setbuf(stdout, (char *)NULL);
-		setbuf(stderr, (char *)NULL);
-	}
+    if (unbuffered) {
+        setbuf(stdin, (char *)NULL);
+        setbuf(stdout, (char *)NULL);
+        setbuf(stderr, (char *)NULL);
+    }
 
 #ifdef MS_WINDOWS
-	PyInitFrozenExtensions();
+    PyInitFrozenExtensions();
 #endif /* MS_WINDOWS */
-	Py_SetProgramName(argv[0]);
-	Py_Initialize();
+    Py_SetProgramName(argv[0]);
+    Py_Initialize();
 #ifdef MS_WINDOWS
-	PyWinFreeze_ExeInit();
+    PyWinFreeze_ExeInit();
 #endif
 
-	if (Py_VerboseFlag)
-		fprintf(stderr, "Python %s\n%s\n",
-			Py_GetVersion(), Py_GetCopyright());
+    if (Py_VerboseFlag)
+        fprintf(stderr, "Python %s\n%s\n",
+            Py_GetVersion(), Py_GetCopyright());
 
-	PySys_SetArgv(argc, argv);
+    PySys_SetArgv(argc, argv);
 
-	n = PyImport_ImportFrozenModule("__main__");
-	if (n == 0)
-		Py_FatalError("__main__ not frozen");
-	if (n < 0) {
-		PyErr_Print();
-		sts = 1;
-	}
-	else
-		sts = 0;
+    n = PyImport_ImportFrozenModule("__main__");
+    if (n == 0)
+        Py_FatalError("__main__ not frozen");
+    if (n < 0) {
+        PyErr_Print();
+        sts = 1;
+    }
+    else
+        sts = 0;
 
-	if (inspect && isatty((int)fileno(stdin)))
-		sts = PyRun_AnyFile(stdin, "<stdin>") != 0;
+    if (inspect && isatty((int)fileno(stdin)))
+        sts = PyRun_AnyFile(stdin, "<stdin>") != 0;
 
 #ifdef MS_WINDOWS
-	PyWinFreeze_ExeTerm();
+    PyWinFreeze_ExeTerm();
 #endif
-	Py_Finalize();
-	return sts;
+    Py_Finalize();
+    return sts;
 }
diff --git a/Python/future.c b/Python/future.c
index 532a7fd..96be757 100644
--- a/Python/future.c
+++ b/Python/future.c
@@ -14,129 +14,129 @@
 static int
 future_check_features(PyFutureFeatures *ff, stmt_ty s, const char *filename)
 {
-	int i;
-	asdl_seq *names;
-
-	assert(s->kind == ImportFrom_kind);
-
-	names = s->v.ImportFrom.names;
-	for (i = 0; i < asdl_seq_LEN(names); i++) {
-                alias_ty name = (alias_ty)asdl_seq_GET(names, i);
-		const char *feature = PyString_AsString(name->name);
-		if (!feature)
-			return 0;
-		if (strcmp(feature, FUTURE_NESTED_SCOPES) == 0) {
-			continue;
-		} else if (strcmp(feature, FUTURE_GENERATORS) == 0) {
-			continue;
-		} else if (strcmp(feature, FUTURE_DIVISION) == 0) {
-			ff->ff_features |= CO_FUTURE_DIVISION;
-		} else if (strcmp(feature, FUTURE_ABSOLUTE_IMPORT) == 0) {
-			ff->ff_features |= CO_FUTURE_ABSOLUTE_IMPORT;
-		} else if (strcmp(feature, FUTURE_WITH_STATEMENT) == 0) {
-			ff->ff_features |= CO_FUTURE_WITH_STATEMENT;
-		} else if (strcmp(feature, FUTURE_PRINT_FUNCTION) == 0) {
-			ff->ff_features |= CO_FUTURE_PRINT_FUNCTION;
-		} else if (strcmp(feature, FUTURE_UNICODE_LITERALS) == 0) {
-			ff->ff_features |= CO_FUTURE_UNICODE_LITERALS;
-		} else if (strcmp(feature, "braces") == 0) {
-			PyErr_SetString(PyExc_SyntaxError,
-					"not a chance");
-			PyErr_SyntaxLocation(filename, s->lineno);
-			return 0;
-		} else {
-			PyErr_Format(PyExc_SyntaxError,
-				     UNDEFINED_FUTURE_FEATURE, feature);
-			PyErr_SyntaxLocation(filename, s->lineno);
-			return 0;
-		}
-	}
-	return 1;
+    int i;
+    asdl_seq *names;
+
+    assert(s->kind == ImportFrom_kind);
+
+    names = s->v.ImportFrom.names;
+    for (i = 0; i < asdl_seq_LEN(names); i++) {
+        alias_ty name = (alias_ty)asdl_seq_GET(names, i);
+        const char *feature = PyString_AsString(name->name);
+        if (!feature)
+            return 0;
+        if (strcmp(feature, FUTURE_NESTED_SCOPES) == 0) {
+            continue;
+        } else if (strcmp(feature, FUTURE_GENERATORS) == 0) {
+            continue;
+        } else if (strcmp(feature, FUTURE_DIVISION) == 0) {
+            ff->ff_features |= CO_FUTURE_DIVISION;
+        } else if (strcmp(feature, FUTURE_ABSOLUTE_IMPORT) == 0) {
+            ff->ff_features |= CO_FUTURE_ABSOLUTE_IMPORT;
+        } else if (strcmp(feature, FUTURE_WITH_STATEMENT) == 0) {
+            ff->ff_features |= CO_FUTURE_WITH_STATEMENT;
+        } else if (strcmp(feature, FUTURE_PRINT_FUNCTION) == 0) {
+            ff->ff_features |= CO_FUTURE_PRINT_FUNCTION;
+        } else if (strcmp(feature, FUTURE_UNICODE_LITERALS) == 0) {
+            ff->ff_features |= CO_FUTURE_UNICODE_LITERALS;
+        } else if (strcmp(feature, "braces") == 0) {
+            PyErr_SetString(PyExc_SyntaxError,
+                            "not a chance");
+            PyErr_SyntaxLocation(filename, s->lineno);
+            return 0;
+        } else {
+            PyErr_Format(PyExc_SyntaxError,
+                         UNDEFINED_FUTURE_FEATURE, feature);
+            PyErr_SyntaxLocation(filename, s->lineno);
+            return 0;
+        }
+    }
+    return 1;
 }
 
 static int
 future_parse(PyFutureFeatures *ff, mod_ty mod, const char *filename)
 {
-	int i, found_docstring = 0, done = 0, prev_line = 0;
-
-	static PyObject *future;
-	if (!future) {
-		future = PyString_InternFromString("__future__");
-		if (!future)
-			return 0;
-	}
-
-	if (!(mod->kind == Module_kind || mod->kind == Interactive_kind))
-		return 1;
-
-	/* A subsequent pass will detect future imports that don't
-	   appear at the beginning of the file.  There's one case,
-	   however, that is easier to handle here: A series of imports
-	   joined by semi-colons, where the first import is a future
-	   statement but some subsequent import has the future form
-	   but is preceded by a regular import.
-	*/
-	   
-
-	for (i = 0; i < asdl_seq_LEN(mod->v.Module.body); i++) {
-		stmt_ty s = (stmt_ty)asdl_seq_GET(mod->v.Module.body, i);
-
-		if (done && s->lineno > prev_line)
-			return 1;
-		prev_line = s->lineno;
-
-		/* The tests below will return from this function unless it is
-		   still possible to find a future statement.  The only things
-		   that can precede a future statement are another future
-		   statement and a doc string.
-		*/
-
-		if (s->kind == ImportFrom_kind) {
-			if (s->v.ImportFrom.module == future) {
-				if (done) {
-					PyErr_SetString(PyExc_SyntaxError,
-							ERR_LATE_FUTURE);
-					PyErr_SyntaxLocation(filename, 
-							     s->lineno);
-					return 0;
-				}
-				if (!future_check_features(ff, s, filename))
-					return 0;
-				ff->ff_lineno = s->lineno;
-			}
-			else
-				done = 1;
-		}
-		else if (s->kind == Expr_kind && !found_docstring) {
-			expr_ty e = s->v.Expr.value;
-			if (e->kind != Str_kind)
-				done = 1;
-			else
-				found_docstring = 1;
-		}
-		else
-			done = 1;
-	}
-	return 1;
+    int i, found_docstring = 0, done = 0, prev_line = 0;
+
+    static PyObject *future;
+    if (!future) {
+        future = PyString_InternFromString("__future__");
+        if (!future)
+            return 0;
+    }
+
+    if (!(mod->kind == Module_kind || mod->kind == Interactive_kind))
+        return 1;
+
+    /* A subsequent pass will detect future imports that don't
+       appear at the beginning of the file.  There's one case,
+       however, that is easier to handle here: A series of imports
+       joined by semi-colons, where the first import is a future
+       statement but some subsequent import has the future form
+       but is preceded by a regular import.
+    */
+
+
+    for (i = 0; i < asdl_seq_LEN(mod->v.Module.body); i++) {
+        stmt_ty s = (stmt_ty)asdl_seq_GET(mod->v.Module.body, i);
+
+        if (done && s->lineno > prev_line)
+            return 1;
+        prev_line = s->lineno;
+
+        /* The tests below will return from this function unless it is
+           still possible to find a future statement.  The only things
+           that can precede a future statement are another future
+           statement and a doc string.
+        */
+
+        if (s->kind == ImportFrom_kind) {
+            if (s->v.ImportFrom.module == future) {
+                if (done) {
+                    PyErr_SetString(PyExc_SyntaxError,
+                                    ERR_LATE_FUTURE);
+                    PyErr_SyntaxLocation(filename,
+                                         s->lineno);
+                    return 0;
+                }
+                if (!future_check_features(ff, s, filename))
+                    return 0;
+                ff->ff_lineno = s->lineno;
+            }
+            else
+                done = 1;
+        }
+        else if (s->kind == Expr_kind && !found_docstring) {
+            expr_ty e = s->v.Expr.value;
+            if (e->kind != Str_kind)
+                done = 1;
+            else
+                found_docstring = 1;
+        }
+        else
+            done = 1;
+    }
+    return 1;
 }
 
 
 PyFutureFeatures *
 PyFuture_FromAST(mod_ty mod, const char *filename)
 {
-	PyFutureFeatures *ff;
-
-	ff = (PyFutureFeatures *)PyObject_Malloc(sizeof(PyFutureFeatures));
-	if (ff == NULL) {
-		PyErr_NoMemory();
-		return NULL;
-	}
-	ff->ff_features = 0;
-	ff->ff_lineno = -1;
-
-	if (!future_parse(ff, mod, filename)) {
-		PyObject_Free(ff);
-		return NULL;
-	}
-	return ff;
+    PyFutureFeatures *ff;
+
+    ff = (PyFutureFeatures *)PyObject_Malloc(sizeof(PyFutureFeatures));
+    if (ff == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    ff->ff_features = 0;
+    ff->ff_lineno = -1;
+
+    if (!future_parse(ff, mod, filename)) {
+        PyObject_Free(ff);
+        return NULL;
+    }
+    return ff;
 }
diff --git a/Python/getargs.c b/Python/getargs.c
index 502e9cd..7c3e9fa 100644
--- a/Python/getargs.c
+++ b/Python/getargs.c
@@ -7,16 +7,16 @@
 
 
 #ifdef __cplusplus
-extern "C" { 
+extern "C" {
 #endif
 int PyArg_Parse(PyObject *, const char *, ...);
 int PyArg_ParseTuple(PyObject *, const char *, ...);
 int PyArg_VaParse(PyObject *, const char *, va_list);
 
 int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
-				const char *, char **, ...);
+                                const char *, char **, ...);
 int PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,
-				const char *, char **, va_list);
+                                const char *, char **, va_list);
 
 #ifdef HAVE_DECLSPEC_DLL
 /* Export functions */
@@ -37,103 +37,103 @@ PyAPI_FUNC(int) _PyArg_VaParseTupleAndKeywords_SizeT(PyObject *, PyObject *,
 /* Forward */
 static int vgetargs1(PyObject *, const char *, va_list *, int);
 static void seterror(int, const char *, int *, const char *, const char *);
-static char *convertitem(PyObject *, const char **, va_list *, int, int *, 
+static char *convertitem(PyObject *, const char **, va_list *, int, int *,
                          char *, size_t, PyObject **);
 static char *converttuple(PyObject *, const char **, va_list *, int,
-			  int *, char *, size_t, int, PyObject **);
+                          int *, char *, size_t, int, PyObject **);
 static char *convertsimple(PyObject *, const char **, va_list *, int, char *,
-			   size_t, PyObject **);
+                           size_t, PyObject **);
 static Py_ssize_t convertbuffer(PyObject *, void **p, char **);
 static int getbuffer(PyObject *, Py_buffer *, char**);
 
 static int vgetargskeywords(PyObject *, PyObject *,
-			    const char *, char **, va_list *, int);
+                            const char *, char **, va_list *, int);
 static char *skipitem(const char **, va_list *, int);
 
 int
 PyArg_Parse(PyObject *args, const char *format, ...)
 {
-	int retval;
-	va_list va;
-	
-	va_start(va, format);
-	retval = vgetargs1(args, format, &va, FLAG_COMPAT);
-	va_end(va);
-	return retval;
+    int retval;
+    va_list va;
+
+    va_start(va, format);
+    retval = vgetargs1(args, format, &va, FLAG_COMPAT);
+    va_end(va);
+    return retval;
 }
 
 int
 _PyArg_Parse_SizeT(PyObject *args, char *format, ...)
 {
-	int retval;
-	va_list va;
-	
-	va_start(va, format);
-	retval = vgetargs1(args, format, &va, FLAG_COMPAT|FLAG_SIZE_T);
-	va_end(va);
-	return retval;
+    int retval;
+    va_list va;
+
+    va_start(va, format);
+    retval = vgetargs1(args, format, &va, FLAG_COMPAT|FLAG_SIZE_T);
+    va_end(va);
+    return retval;
 }
 
 
 int
 PyArg_ParseTuple(PyObject *args, const char *format, ...)
 {
-	int retval;
-	va_list va;
-	
-	va_start(va, format);
-	retval = vgetargs1(args, format, &va, 0);
-	va_end(va);
-	return retval;
+    int retval;
+    va_list va;
+
+    va_start(va, format);
+    retval = vgetargs1(args, format, &va, 0);
+    va_end(va);
+    return retval;
 }
 
 int
 _PyArg_ParseTuple_SizeT(PyObject *args, char *format, ...)
 {
-	int retval;
-	va_list va;
-	
-	va_start(va, format);
-	retval = vgetargs1(args, format, &va, FLAG_SIZE_T);
-	va_end(va);
-	return retval;
+    int retval;
+    va_list va;
+
+    va_start(va, format);
+    retval = vgetargs1(args, format, &va, FLAG_SIZE_T);
+    va_end(va);
+    return retval;
 }
 
 
 int
 PyArg_VaParse(PyObject *args, const char *format, va_list va)
 {
-	va_list lva;
+    va_list lva;
 
 #ifdef VA_LIST_IS_ARRAY
-	memcpy(lva, va, sizeof(va_list));
+    memcpy(lva, va, sizeof(va_list));
 #else
 #ifdef __va_copy
-	__va_copy(lva, va);
+    __va_copy(lva, va);
 #else
-	lva = va;
+    lva = va;
 #endif
 #endif
 
-	return vgetargs1(args, format, &lva, 0);
+    return vgetargs1(args, format, &lva, 0);
 }
 
 int
 _PyArg_VaParse_SizeT(PyObject *args, char *format, va_list va)
 {
-	va_list lva;
+    va_list lva;
 
 #ifdef VA_LIST_IS_ARRAY
-	memcpy(lva, va, sizeof(va_list));
+    memcpy(lva, va, sizeof(va_list));
 #else
 #ifdef __va_copy
-	__va_copy(lva, va);
+    __va_copy(lva, va);
 #else
-	lva = va;
+    lva = va;
 #endif
 #endif
 
-	return vgetargs1(args, format, &lva, FLAG_SIZE_T);
+    return vgetargs1(args, format, &lva, FLAG_SIZE_T);
 }
 
 
@@ -145,221 +145,221 @@ _PyArg_VaParse_SizeT(PyObject *args, char *format, va_list va)
 static void
 cleanup_ptr(PyObject *self)
 {
-	void *ptr = PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_PTR);
-	if (ptr) {
-	  PyMem_FREE(ptr);
-	}
+    void *ptr = PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_PTR);
+    if (ptr) {
+      PyMem_FREE(ptr);
+    }
 }
 
 static void
 cleanup_buffer(PyObject *self)
 {
-	Py_buffer *ptr = (Py_buffer *)PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_BUFFER);
-	if (ptr) {
-		PyBuffer_Release(ptr);
-	}
+    Py_buffer *ptr = (Py_buffer *)PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_BUFFER);
+    if (ptr) {
+        PyBuffer_Release(ptr);
+    }
 }
 
 static int
 addcleanup(void *ptr, PyObject **freelist, PyCapsule_Destructor destr)
 {
-	PyObject *cobj;
-	const char *name;
-
-	if (!*freelist) {
-		*freelist = PyList_New(0);
-		if (!*freelist) {
-			destr(ptr);
-			return -1;
-		}
-	}
-
-	if (destr == cleanup_ptr) {
-		name = GETARGS_CAPSULE_NAME_CLEANUP_PTR;
-	} else if (destr == cleanup_buffer) {
-		name = GETARGS_CAPSULE_NAME_CLEANUP_BUFFER;
-	} else {
-		return -1;
-	}
-	cobj = PyCapsule_New(ptr, name, destr);
-	if (!cobj) {
-		destr(ptr);
-		return -1;
-	}
-	if (PyList_Append(*freelist, cobj)) {
-		Py_DECREF(cobj);
-		return -1;
-	}
+    PyObject *cobj;
+    const char *name;
+
+    if (!*freelist) {
+        *freelist = PyList_New(0);
+        if (!*freelist) {
+            destr(ptr);
+            return -1;
+        }
+    }
+
+    if (destr == cleanup_ptr) {
+        name = GETARGS_CAPSULE_NAME_CLEANUP_PTR;
+    } else if (destr == cleanup_buffer) {
+        name = GETARGS_CAPSULE_NAME_CLEANUP_BUFFER;
+    } else {
+        return -1;
+    }
+    cobj = PyCapsule_New(ptr, name, destr);
+    if (!cobj) {
+        destr(ptr);
+        return -1;
+    }
+    if (PyList_Append(*freelist, cobj)) {
         Py_DECREF(cobj);
-	return 0;
+        return -1;
+    }
+    Py_DECREF(cobj);
+    return 0;
 }
 
 static int
 cleanreturn(int retval, PyObject *freelist)
 {
-	if (freelist && retval != 0) {
-		/* We were successful, reset the destructors so that they
-		   don't get called. */
-		Py_ssize_t len = PyList_GET_SIZE(freelist), i;
-		for (i = 0; i < len; i++)
-			PyCapsule_SetDestructor(PyList_GET_ITEM(freelist, i), NULL);
-	}
-	Py_XDECREF(freelist);
-	return retval;
+    if (freelist && retval != 0) {
+        /* We were successful, reset the destructors so that they
+           don't get called. */
+        Py_ssize_t len = PyList_GET_SIZE(freelist), i;
+        for (i = 0; i < len; i++)
+            PyCapsule_SetDestructor(PyList_GET_ITEM(freelist, i), NULL);
+    }
+    Py_XDECREF(freelist);
+    return retval;
 }
 
 
 static int
 vgetargs1(PyObject *args, const char *format, va_list *p_va, int flags)
 {
-	char msgbuf[256];
-	int levels[32];
-	const char *fname = NULL;
-	const char *message = NULL;
-	int min = -1;
-	int max = 0;
-	int level = 0;
-	int endfmt = 0;
-	const char *formatsave = format;
-	Py_ssize_t i, len;
-	char *msg;
-	PyObject *freelist = NULL;
-	int compat = flags & FLAG_COMPAT;
-
-	assert(compat || (args != (PyObject*)NULL));
-	flags = flags & ~FLAG_COMPAT;
-
-	while (endfmt == 0) {
-		int c = *format++;
-		switch (c) {
-		case '(':
-			if (level == 0)
-				max++;
-			level++;
-			if (level >= 30)
-				Py_FatalError("too many tuple nesting levels "
-					      "in argument format string");
-			break;
-		case ')':
-			if (level == 0)
-				Py_FatalError("excess ')' in getargs format");
-			else
-				level--;
-			break;
-		case '\0':
-			endfmt = 1;
-			break;
-		case ':':
-			fname = format;
-			endfmt = 1;
-			break;
-		case ';':
-			message = format;
-			endfmt = 1;
-			break;
-		default:
-			if (level == 0) {
-				if (c == 'O')
-					max++;
-				else if (isalpha(Py_CHARMASK(c))) {
-					if (c != 'e') /* skip encoded */
-						max++;
-				} else if (c == '|')
-					min = max;
-			}
-			break;
-		}
-	}
-	
-	if (level != 0)
-		Py_FatalError(/* '(' */ "missing ')' in getargs format");
-	
-	if (min < 0)
-		min = max;
-	
-	format = formatsave;
-	
-	if (compat) {
-		if (max == 0) {
-			if (args == NULL)
-				return 1;
-			PyOS_snprintf(msgbuf, sizeof(msgbuf),
-				      "%.200s%s takes no arguments",
-				      fname==NULL ? "function" : fname,
-				      fname==NULL ? "" : "()");
-			PyErr_SetString(PyExc_TypeError, msgbuf);
-			return 0;
-		}
-		else if (min == 1 && max == 1) {
-			if (args == NULL) {
-				PyOS_snprintf(msgbuf, sizeof(msgbuf),
-				      "%.200s%s takes at least one argument",
-					      fname==NULL ? "function" : fname,
-					      fname==NULL ? "" : "()");
-				PyErr_SetString(PyExc_TypeError, msgbuf);
-				return 0;
-			}
-			msg = convertitem(args, &format, p_va, flags, levels, 
-					  msgbuf, sizeof(msgbuf), &freelist);
-			if (msg == NULL)
-				return cleanreturn(1, freelist);
-			seterror(levels[0], msg, levels+1, fname, message);
-			return cleanreturn(0, freelist);
-		}
-		else {
-			PyErr_SetString(PyExc_SystemError,
-			    "old style getargs format uses new features");
-			return 0;
-		}
-	}
-	
-	if (!PyTuple_Check(args)) {
-		PyErr_SetString(PyExc_SystemError,
-		    "new style getargs format but argument is not a tuple");
-		return 0;
-	}
-	
-	len = PyTuple_GET_SIZE(args);
-	
-	if (len < min || max < len) {
-		if (message == NULL) {
-			PyOS_snprintf(msgbuf, sizeof(msgbuf),
-				      "%.150s%s takes %s %d argument%s "
-				      "(%ld given)",
-				      fname==NULL ? "function" : fname,
-				      fname==NULL ? "" : "()",
-				      min==max ? "exactly"
-				      : len < min ? "at least" : "at most",
-				      len < min ? min : max,
-				      (len < min ? min : max) == 1 ? "" : "s",
-				      Py_SAFE_DOWNCAST(len, Py_ssize_t, long));
-			message = msgbuf;
-		}
-		PyErr_SetString(PyExc_TypeError, message);
-		return 0;
-	}
-	
-	for (i = 0; i < len; i++) {
-		if (*format == '|')
-			format++;
-		msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
-				  flags, levels, msgbuf, 
-				  sizeof(msgbuf), &freelist);
-		if (msg) {
-			seterror(i+1, msg, levels, fname, msg);
-			return cleanreturn(0, freelist);
-		}
-	}
-
-	if (*format != '\0' && !isalpha(Py_CHARMASK(*format)) &&
-	    *format != '(' &&
-	    *format != '|' && *format != ':' && *format != ';') {
-		PyErr_Format(PyExc_SystemError,
-			     "bad format string: %.200s", formatsave);
-		return cleanreturn(0, freelist);
-	}
-	
-	return cleanreturn(1, freelist);
+    char msgbuf[256];
+    int levels[32];
+    const char *fname = NULL;
+    const char *message = NULL;
+    int min = -1;
+    int max = 0;
+    int level = 0;
+    int endfmt = 0;
+    const char *formatsave = format;
+    Py_ssize_t i, len;
+    char *msg;
+    PyObject *freelist = NULL;
+    int compat = flags & FLAG_COMPAT;
+
+    assert(compat || (args != (PyObject*)NULL));
+    flags = flags & ~FLAG_COMPAT;
+
+    while (endfmt == 0) {
+        int c = *format++;
+        switch (c) {
+        case '(':
+            if (level == 0)
+                max++;
+            level++;
+            if (level >= 30)
+                Py_FatalError("too many tuple nesting levels "
+                              "in argument format string");
+            break;
+        case ')':
+            if (level == 0)
+                Py_FatalError("excess ')' in getargs format");
+            else
+                level--;
+            break;
+        case '\0':
+            endfmt = 1;
+            break;
+        case ':':
+            fname = format;
+            endfmt = 1;
+            break;
+        case ';':
+            message = format;
+            endfmt = 1;
+            break;
+        default:
+            if (level == 0) {
+                if (c == 'O')
+                    max++;
+                else if (isalpha(Py_CHARMASK(c))) {
+                    if (c != 'e') /* skip encoded */
+                        max++;
+                } else if (c == '|')
+                    min = max;
+            }
+            break;
+        }
+    }
+
+    if (level != 0)
+        Py_FatalError(/* '(' */ "missing ')' in getargs format");
+
+    if (min < 0)
+        min = max;
+
+    format = formatsave;
+
+    if (compat) {
+        if (max == 0) {
+            if (args == NULL)
+                return 1;
+            PyOS_snprintf(msgbuf, sizeof(msgbuf),
+                          "%.200s%s takes no arguments",
+                          fname==NULL ? "function" : fname,
+                          fname==NULL ? "" : "()");
+            PyErr_SetString(PyExc_TypeError, msgbuf);
+            return 0;
+        }
+        else if (min == 1 && max == 1) {
+            if (args == NULL) {
+                PyOS_snprintf(msgbuf, sizeof(msgbuf),
+                      "%.200s%s takes at least one argument",
+                          fname==NULL ? "function" : fname,
+                          fname==NULL ? "" : "()");
+                PyErr_SetString(PyExc_TypeError, msgbuf);
+                return 0;
+            }
+            msg = convertitem(args, &format, p_va, flags, levels,
+                              msgbuf, sizeof(msgbuf), &freelist);
+            if (msg == NULL)
+                return cleanreturn(1, freelist);
+            seterror(levels[0], msg, levels+1, fname, message);
+            return cleanreturn(0, freelist);
+        }
+        else {
+            PyErr_SetString(PyExc_SystemError,
+                "old style getargs format uses new features");
+            return 0;
+        }
+    }
+
+    if (!PyTuple_Check(args)) {
+        PyErr_SetString(PyExc_SystemError,
+            "new style getargs format but argument is not a tuple");
+        return 0;
+    }
+
+    len = PyTuple_GET_SIZE(args);
+
+    if (len < min || max < len) {
+        if (message == NULL) {
+            PyOS_snprintf(msgbuf, sizeof(msgbuf),
+                          "%.150s%s takes %s %d argument%s "
+                          "(%ld given)",
+                          fname==NULL ? "function" : fname,
+                          fname==NULL ? "" : "()",
+                          min==max ? "exactly"
+                          : len < min ? "at least" : "at most",
+                          len < min ? min : max,
+                          (len < min ? min : max) == 1 ? "" : "s",
+                          Py_SAFE_DOWNCAST(len, Py_ssize_t, long));
+            message = msgbuf;
+        }
+        PyErr_SetString(PyExc_TypeError, message);
+        return 0;
+    }
+
+    for (i = 0; i < len; i++) {
+        if (*format == '|')
+            format++;
+        msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
+                          flags, levels, msgbuf,
+                          sizeof(msgbuf), &freelist);
+        if (msg) {
+            seterror(i+1, msg, levels, fname, msg);
+            return cleanreturn(0, freelist);
+        }
+    }
+
+    if (*format != '\0' && !isalpha(Py_CHARMASK(*format)) &&
+        *format != '(' &&
+        *format != '|' && *format != ':' && *format != ';') {
+        PyErr_Format(PyExc_SystemError,
+                     "bad format string: %.200s", formatsave);
+        return cleanreturn(0, freelist);
+    }
+
+    return cleanreturn(1, freelist);
 }
 
 
@@ -368,37 +368,37 @@ static void
 seterror(int iarg, const char *msg, int *levels, const char *fname,
          const char *message)
 {
-	char buf[512];
-	int i;
-	char *p = buf;
-
-	if (PyErr_Occurred())
-		return;
-	else if (message == NULL) {
-		if (fname != NULL) {
-			PyOS_snprintf(p, sizeof(buf), "%.200s() ", fname);
-			p += strlen(p);
-		}
-		if (iarg != 0) {
-			PyOS_snprintf(p, sizeof(buf) - (p - buf),
-				      "argument %d", iarg);
-			i = 0;
-			p += strlen(p);
-			while (levels[i] > 0 && i < 32 && (int)(p-buf) < 220) {
-				PyOS_snprintf(p, sizeof(buf) - (p - buf),
-					      ", item %d", levels[i]-1);
-				p += strlen(p);
-				i++;
-			}
-		}
-		else {
-			PyOS_snprintf(p, sizeof(buf) - (p - buf), "argument");
-			p += strlen(p);
-		}
-		PyOS_snprintf(p, sizeof(buf) - (p - buf), " %.256s", msg);
-		message = buf;
-	}
-	PyErr_SetString(PyExc_TypeError, message);
+    char buf[512];
+    int i;
+    char *p = buf;
+
+    if (PyErr_Occurred())
+        return;
+    else if (message == NULL) {
+        if (fname != NULL) {
+            PyOS_snprintf(p, sizeof(buf), "%.200s() ", fname);
+            p += strlen(p);
+        }
+        if (iarg != 0) {
+            PyOS_snprintf(p, sizeof(buf) - (p - buf),
+                          "argument %d", iarg);
+            i = 0;
+            p += strlen(p);
+            while (levels[i] > 0 && i < 32 && (int)(p-buf) < 220) {
+                PyOS_snprintf(p, sizeof(buf) - (p - buf),
+                              ", item %d", levels[i]-1);
+                p += strlen(p);
+                i++;
+            }
+        }
+        else {
+            PyOS_snprintf(p, sizeof(buf) - (p - buf), "argument");
+            p += strlen(p);
+        }
+        PyOS_snprintf(p, sizeof(buf) - (p - buf), " %.256s", msg);
+        message = buf;
+    }
+    PyErr_SetString(PyExc_TypeError, message);
 }
 
 
@@ -414,83 +414,83 @@ seterror(int iarg, const char *msg, int *levels, const char *fname,
       *p_va is undefined,
       *levels is a 0-terminated list of item numbers,
       *msgbuf contains an error message, whose format is:
-         "must be <typename1>, not <typename2>", where:
-            <typename1> is the name of the expected type, and
-            <typename2> is the name of the actual type,
+     "must be <typename1>, not <typename2>", where:
+        <typename1> is the name of the expected type, and
+        <typename2> is the name of the actual type,
       and msgbuf is returned.
 */
 
 static char *
 converttuple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
-             int *levels, char *msgbuf, size_t bufsize, int toplevel, 
+             int *levels, char *msgbuf, size_t bufsize, int toplevel,
              PyObject **freelist)
 {
-	int level = 0;
-	int n = 0;
-	const char *format = *p_format;
-	int i;
-	
-	for (;;) {
-		int c = *format++;
-		if (c == '(') {
-			if (level == 0)
-				n++;
-			level++;
-		}
-		else if (c == ')') {
-			if (level == 0)
-				break;
-			level--;
-		}
-		else if (c == ':' || c == ';' || c == '\0')
-			break;
-		else if (level == 0 && isalpha(Py_CHARMASK(c)))
-			n++;
-	}
-	
-	if (!PySequence_Check(arg) || PyString_Check(arg)) {
-		levels[0] = 0;
-		PyOS_snprintf(msgbuf, bufsize,
-			      toplevel ? "expected %d arguments, not %.50s" :
-			              "must be %d-item sequence, not %.50s",
-			      n, 
-			      arg == Py_None ? "None" : arg->ob_type->tp_name);
-		return msgbuf;
-	}
-	
-	if ((i = PySequence_Size(arg)) != n) {
-		levels[0] = 0;
-		PyOS_snprintf(msgbuf, bufsize,
-			      toplevel ? "expected %d arguments, not %d" :
-			             "must be sequence of length %d, not %d",
-			      n, i);
-		return msgbuf;
-	}
-
-	format = *p_format;
-	for (i = 0; i < n; i++) {
-		char *msg;
-		PyObject *item;
-		item = PySequence_GetItem(arg, i);
-		if (item == NULL) {
-			PyErr_Clear();
-			levels[0] = i+1;
-			levels[1] = 0;
-			strncpy(msgbuf, "is not retrievable", bufsize);
-			return msgbuf;
-		}
-		msg = convertitem(item, &format, p_va, flags, levels+1, 
-				  msgbuf, bufsize, freelist);
-		/* PySequence_GetItem calls tp->sq_item, which INCREFs */
-		Py_XDECREF(item);
-		if (msg != NULL) {
-			levels[0] = i+1;
-			return msg;
-		}
-	}
-
-	*p_format = format;
-	return NULL;
+    int level = 0;
+    int n = 0;
+    const char *format = *p_format;
+    int i;
+
+    for (;;) {
+        int c = *format++;
+        if (c == '(') {
+            if (level == 0)
+                n++;
+            level++;
+        }
+        else if (c == ')') {
+            if (level == 0)
+                break;
+            level--;
+        }
+        else if (c == ':' || c == ';' || c == '\0')
+            break;
+        else if (level == 0 && isalpha(Py_CHARMASK(c)))
+            n++;
+    }
+
+    if (!PySequence_Check(arg) || PyString_Check(arg)) {
+        levels[0] = 0;
+        PyOS_snprintf(msgbuf, bufsize,
+                      toplevel ? "expected %d arguments, not %.50s" :
+                      "must be %d-item sequence, not %.50s",
+                  n,
+                  arg == Py_None ? "None" : arg->ob_type->tp_name);
+        return msgbuf;
+    }
+
+    if ((i = PySequence_Size(arg)) != n) {
+        levels[0] = 0;
+        PyOS_snprintf(msgbuf, bufsize,
+                      toplevel ? "expected %d arguments, not %d" :
+                     "must be sequence of length %d, not %d",
+                  n, i);
+        return msgbuf;
+    }
+
+    format = *p_format;
+    for (i = 0; i < n; i++) {
+        char *msg;
+        PyObject *item;
+        item = PySequence_GetItem(arg, i);
+        if (item == NULL) {
+            PyErr_Clear();
+            levels[0] = i+1;
+            levels[1] = 0;
+            strncpy(msgbuf, "is not retrievable", bufsize);
+            return msgbuf;
+        }
+        msg = convertitem(item, &format, p_va, flags, levels+1,
+                          msgbuf, bufsize, freelist);
+        /* PySequence_GetItem calls tp->sq_item, which INCREFs */
+        Py_XDECREF(item);
+        if (msg != NULL) {
+            levels[0] = i+1;
+            return msg;
+        }
+    }
+
+    *p_format = format;
+    return NULL;
 }
 
 
@@ -500,43 +500,43 @@ static char *
 convertitem(PyObject *arg, const char **p_format, va_list *p_va, int flags,
             int *levels, char *msgbuf, size_t bufsize, PyObject **freelist)
 {
-	char *msg;
-	const char *format = *p_format;
-	
-	if (*format == '(' /* ')' */) {
-		format++;
-		msg = converttuple(arg, &format, p_va, flags, levels, msgbuf, 
-				   bufsize, 0, freelist);
-		if (msg == NULL)
-			format++;
-	}
-	else {
-		msg = convertsimple(arg, &format, p_va, flags, 
-				    msgbuf, bufsize, freelist);
-		if (msg != NULL)
-			levels[0] = 0;
-	}
-	if (msg == NULL)
-		*p_format = format;
-	return msg;
+    char *msg;
+    const char *format = *p_format;
+
+    if (*format == '(' /* ')' */) {
+        format++;
+        msg = converttuple(arg, &format, p_va, flags, levels, msgbuf,
+                           bufsize, 0, freelist);
+        if (msg == NULL)
+            format++;
+    }
+    else {
+        msg = convertsimple(arg, &format, p_va, flags,
+                            msgbuf, bufsize, freelist);
+        if (msg != NULL)
+            levels[0] = 0;
+    }
+    if (msg == NULL)
+        *p_format = format;
+    return msg;
 }
 
 
 
 #define UNICODE_DEFAULT_ENCODING(arg) \
-        _PyUnicode_AsDefaultEncodedString(arg, NULL)
+    _PyUnicode_AsDefaultEncodedString(arg, NULL)
 
 /* Format an error message generated by convertsimple(). */
 
 static char *
 converterr(const char *expected, PyObject *arg, char *msgbuf, size_t bufsize)
 {
-	assert(expected != NULL);
-	assert(arg != NULL); 
-	PyOS_snprintf(msgbuf, bufsize,
-		      "must be %.50s, not %.50s", expected,
-		      arg == Py_None ? "None" : arg->ob_type->tp_name);
-	return msgbuf;
+    assert(expected != NULL);
+    assert(arg != NULL);
+    PyOS_snprintf(msgbuf, bufsize,
+                  "must be %.50s, not %.50s", expected,
+                  arg == Py_None ? "None" : arg->ob_type->tp_name);
+    return msgbuf;
 }
 
 #define CONV_UNICODE "(unicode conversion error)"
@@ -546,12 +546,12 @@ converterr(const char *expected, PyObject *arg, char *msgbuf, size_t bufsize)
 static int
 float_argument_warning(PyObject *arg)
 {
-	if (PyFloat_Check(arg) &&
-	    PyErr_Warn(PyExc_DeprecationWarning,
-		       "integer argument expected, got float" ))
-		return 1;
-	else
-		return 0;
+    if (PyFloat_Check(arg) &&
+        PyErr_Warn(PyExc_DeprecationWarning,
+                   "integer argument expected, got float" ))
+        return 1;
+    else
+        return 0;
 }
 
 /* explicitly check for float arguments when integers are expected.  Raises
@@ -559,13 +559,13 @@ float_argument_warning(PyObject *arg)
 static int
 float_argument_error(PyObject *arg)
 {
-	if (PyFloat_Check(arg)) {
-		PyErr_SetString(PyExc_TypeError,
-				"integer argument expected, got float");
-		return 1;
-	}
-	else
-		return 0;
+    if (PyFloat_Check(arg)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "integer argument expected, got float");
+        return 1;
+    }
+    else
+        return 0;
 }
 
 /* Convert a non-tuple argument.  Return NULL if conversion went OK,
@@ -581,826 +581,826 @@ static char *
 convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
               char *msgbuf, size_t bufsize, PyObject **freelist)
 {
-	/* For # codes */
-#define FETCH_SIZE	int *q=NULL;Py_ssize_t *q2=NULL;\
-	if (flags & FLAG_SIZE_T) q2=va_arg(*p_va, Py_ssize_t*); \
-	else q=va_arg(*p_va, int*);
+    /* For # codes */
+#define FETCH_SIZE      int *q=NULL;Py_ssize_t *q2=NULL;\
+    if (flags & FLAG_SIZE_T) q2=va_arg(*p_va, Py_ssize_t*); \
+    else q=va_arg(*p_va, int*);
 #define STORE_SIZE(s)   if (flags & FLAG_SIZE_T) *q2=s; else *q=s;
 #define BUFFER_LEN      ((flags & FLAG_SIZE_T) ? *q2:*q)
 
-	const char *format = *p_format;
-	char c = *format++;
+    const char *format = *p_format;
+    char c = *format++;
 #ifdef Py_USING_UNICODE
-	PyObject *uarg;
+    PyObject *uarg;
 #endif
-	
-	switch (c) {
-	
-	case 'b': { /* unsigned byte -- very short int */
-		char *p = va_arg(*p_va, char *);
-		long ival;
-		if (float_argument_error(arg))
-			return converterr("integer<b>", arg, msgbuf, bufsize);
-		ival = PyInt_AsLong(arg);
-		if (ival == -1 && PyErr_Occurred())
-			return converterr("integer<b>", arg, msgbuf, bufsize);
-		else if (ival < 0) {
-			PyErr_SetString(PyExc_OverflowError,
-			"unsigned byte integer is less than minimum");
-			return converterr("integer<b>", arg, msgbuf, bufsize);
-		}
-		else if (ival > UCHAR_MAX) {
-			PyErr_SetString(PyExc_OverflowError,
-			"unsigned byte integer is greater than maximum");
-			return converterr("integer<b>", arg, msgbuf, bufsize);
-		}
-		else
-			*p = (unsigned char) ival;
-		break;
-	}
-	
-	case 'B': {/* byte sized bitfield - both signed and unsigned
-		      values allowed */  
-		char *p = va_arg(*p_va, char *);
-		long ival;
-		if (float_argument_error(arg))
-			return converterr("integer<B>", arg, msgbuf, bufsize);
-		ival = PyInt_AsUnsignedLongMask(arg);
-		if (ival == -1 && PyErr_Occurred())
-			return converterr("integer<B>", arg, msgbuf, bufsize);
-		else
-			*p = (unsigned char) ival;
-		break;
-	}
-	
-	case 'h': {/* signed short int */
-		short *p = va_arg(*p_va, short *);
-		long ival;
-		if (float_argument_error(arg))
-			return converterr("integer<h>", arg, msgbuf, bufsize);
-		ival = PyInt_AsLong(arg);
-		if (ival == -1 && PyErr_Occurred())
-			return converterr("integer<h>", arg, msgbuf, bufsize);
-		else if (ival < SHRT_MIN) {
-			PyErr_SetString(PyExc_OverflowError,
-			"signed short integer is less than minimum");
-			return converterr("integer<h>", arg, msgbuf, bufsize);
-		}
-		else if (ival > SHRT_MAX) {
-			PyErr_SetString(PyExc_OverflowError,
-			"signed short integer is greater than maximum");
-			return converterr("integer<h>", arg, msgbuf, bufsize);
-		}
-		else
-			*p = (short) ival;
-		break;
-	}
-	
-	case 'H': { /* short int sized bitfield, both signed and
-		       unsigned allowed */ 
-		unsigned short *p = va_arg(*p_va, unsigned short *);
-		long ival;
-		if (float_argument_error(arg))
-			return converterr("integer<H>", arg, msgbuf, bufsize);
-		ival = PyInt_AsUnsignedLongMask(arg);
-		if (ival == -1 && PyErr_Occurred())
-			return converterr("integer<H>", arg, msgbuf, bufsize);
-		else
-			*p = (unsigned short) ival;
-		break;
-	}
-
-	case 'i': {/* signed int */
-		int *p = va_arg(*p_va, int *);
-		long ival;
-		if (float_argument_error(arg))
-			return converterr("integer<i>", arg, msgbuf, bufsize);
-		ival = PyInt_AsLong(arg);
-		if (ival == -1 && PyErr_Occurred())
-			return converterr("integer<i>", arg, msgbuf, bufsize);
-		else if (ival > INT_MAX) {
-			PyErr_SetString(PyExc_OverflowError,
-				"signed integer is greater than maximum");
-			return converterr("integer<i>", arg, msgbuf, bufsize);
-		}
-		else if (ival < INT_MIN) {
-			PyErr_SetString(PyExc_OverflowError,
-				"signed integer is less than minimum");
-			return converterr("integer<i>", arg, msgbuf, bufsize);
-		}
-		else
-			*p = ival;
-		break;
-	}
-
-	case 'I': { /* int sized bitfield, both signed and
-		       unsigned allowed */ 
-		unsigned int *p = va_arg(*p_va, unsigned int *);
-		unsigned int ival;
-		if (float_argument_error(arg))
-			return converterr("integer<I>", arg, msgbuf, bufsize);
-		ival = (unsigned int)PyInt_AsUnsignedLongMask(arg);
-		if (ival == (unsigned int)-1 && PyErr_Occurred())
-			return converterr("integer<I>", arg, msgbuf, bufsize);
-		else
-			*p = ival;
-		break;
-	}
-	
-	case 'n': /* Py_ssize_t */
+
+    switch (c) {
+
+    case 'b': { /* unsigned byte -- very short int */
+        char *p = va_arg(*p_va, char *);
+        long ival;
+        if (float_argument_error(arg))
+            return converterr("integer<b>", arg, msgbuf, bufsize);
+        ival = PyInt_AsLong(arg);
+        if (ival == -1 && PyErr_Occurred())
+            return converterr("integer<b>", arg, msgbuf, bufsize);
+        else if (ival < 0) {
+            PyErr_SetString(PyExc_OverflowError,
+            "unsigned byte integer is less than minimum");
+            return converterr("integer<b>", arg, msgbuf, bufsize);
+        }
+        else if (ival > UCHAR_MAX) {
+            PyErr_SetString(PyExc_OverflowError,
+            "unsigned byte integer is greater than maximum");
+            return converterr("integer<b>", arg, msgbuf, bufsize);
+        }
+        else
+            *p = (unsigned char) ival;
+        break;
+    }
+
+    case 'B': {/* byte sized bitfield - both signed and unsigned
+                  values allowed */
+        char *p = va_arg(*p_va, char *);
+        long ival;
+        if (float_argument_error(arg))
+            return converterr("integer<B>", arg, msgbuf, bufsize);
+        ival = PyInt_AsUnsignedLongMask(arg);
+        if (ival == -1 && PyErr_Occurred())
+            return converterr("integer<B>", arg, msgbuf, bufsize);
+        else
+            *p = (unsigned char) ival;
+        break;
+    }
+
+    case 'h': {/* signed short int */
+        short *p = va_arg(*p_va, short *);
+        long ival;
+        if (float_argument_error(arg))
+            return converterr("integer<h>", arg, msgbuf, bufsize);
+        ival = PyInt_AsLong(arg);
+        if (ival == -1 && PyErr_Occurred())
+            return converterr("integer<h>", arg, msgbuf, bufsize);
+        else if (ival < SHRT_MIN) {
+            PyErr_SetString(PyExc_OverflowError,
+            "signed short integer is less than minimum");
+            return converterr("integer<h>", arg, msgbuf, bufsize);
+        }
+        else if (ival > SHRT_MAX) {
+            PyErr_SetString(PyExc_OverflowError,
+            "signed short integer is greater than maximum");
+            return converterr("integer<h>", arg, msgbuf, bufsize);
+        }
+        else
+            *p = (short) ival;
+        break;
+    }
+
+    case 'H': { /* short int sized bitfield, both signed and
+                   unsigned allowed */
+        unsigned short *p = va_arg(*p_va, unsigned short *);
+        long ival;
+        if (float_argument_error(arg))
+            return converterr("integer<H>", arg, msgbuf, bufsize);
+        ival = PyInt_AsUnsignedLongMask(arg);
+        if (ival == -1 && PyErr_Occurred())
+            return converterr("integer<H>", arg, msgbuf, bufsize);
+        else
+            *p = (unsigned short) ival;
+        break;
+    }
+
+    case 'i': {/* signed int */
+        int *p = va_arg(*p_va, int *);
+        long ival;
+        if (float_argument_error(arg))
+            return converterr("integer<i>", arg, msgbuf, bufsize);
+        ival = PyInt_AsLong(arg);
+        if (ival == -1 && PyErr_Occurred())
+            return converterr("integer<i>", arg, msgbuf, bufsize);
+        else if (ival > INT_MAX) {
+            PyErr_SetString(PyExc_OverflowError,
+                "signed integer is greater than maximum");
+            return converterr("integer<i>", arg, msgbuf, bufsize);
+        }
+        else if (ival < INT_MIN) {
+            PyErr_SetString(PyExc_OverflowError,
+                "signed integer is less than minimum");
+            return converterr("integer<i>", arg, msgbuf, bufsize);
+        }
+        else
+            *p = ival;
+        break;
+    }
+
+    case 'I': { /* int sized bitfield, both signed and
+                   unsigned allowed */
+        unsigned int *p = va_arg(*p_va, unsigned int *);
+        unsigned int ival;
+        if (float_argument_error(arg))
+            return converterr("integer<I>", arg, msgbuf, bufsize);
+        ival = (unsigned int)PyInt_AsUnsignedLongMask(arg);
+        if (ival == (unsigned int)-1 && PyErr_Occurred())
+            return converterr("integer<I>", arg, msgbuf, bufsize);
+        else
+            *p = ival;
+        break;
+    }
+
+    case 'n': /* Py_ssize_t */
 #if SIZEOF_SIZE_T != SIZEOF_LONG
-	{
-		Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *);
-		Py_ssize_t ival;
-		if (float_argument_error(arg))
-			return converterr("integer<n>", arg, msgbuf, bufsize);
-		ival = PyInt_AsSsize_t(arg);
-		if (ival == -1 && PyErr_Occurred())
-			return converterr("integer<n>", arg, msgbuf, bufsize);
-		*p = ival;
-		break;
-	}
+    {
+        Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *);
+        Py_ssize_t ival;
+        if (float_argument_error(arg))
+            return converterr("integer<n>", arg, msgbuf, bufsize);
+        ival = PyInt_AsSsize_t(arg);
+        if (ival == -1 && PyErr_Occurred())
+            return converterr("integer<n>", arg, msgbuf, bufsize);
+        *p = ival;
+        break;
+    }
 #endif
-	/* Fall through from 'n' to 'l' if Py_ssize_t is int */
-	case 'l': {/* long int */
-		long *p = va_arg(*p_va, long *);
-		long ival;
-		if (float_argument_error(arg))
-			return converterr("integer<l>", arg, msgbuf, bufsize);
-		ival = PyInt_AsLong(arg);
-		if (ival == -1 && PyErr_Occurred())
-			return converterr("integer<l>", arg, msgbuf, bufsize);
-		else
-			*p = ival;
-		break;
-	}
-
-	case 'k': { /* long sized bitfield */
-		unsigned long *p = va_arg(*p_va, unsigned long *);
-		unsigned long ival;
-		if (PyInt_Check(arg))
-			ival = PyInt_AsUnsignedLongMask(arg);
-		else if (PyLong_Check(arg))
-			ival = PyLong_AsUnsignedLongMask(arg);
-		else
-			return converterr("integer<k>", arg, msgbuf, bufsize);
-		*p = ival;
-		break;
-	}
-	
+    /* Fall through from 'n' to 'l' if Py_ssize_t is int */
+    case 'l': {/* long int */
+        long *p = va_arg(*p_va, long *);
+        long ival;
+        if (float_argument_error(arg))
+            return converterr("integer<l>", arg, msgbuf, bufsize);
+        ival = PyInt_AsLong(arg);
+        if (ival == -1 && PyErr_Occurred())
+            return converterr("integer<l>", arg, msgbuf, bufsize);
+        else
+            *p = ival;
+        break;
+    }
+
+    case 'k': { /* long sized bitfield */
+        unsigned long *p = va_arg(*p_va, unsigned long *);
+        unsigned long ival;
+        if (PyInt_Check(arg))
+            ival = PyInt_AsUnsignedLongMask(arg);
+        else if (PyLong_Check(arg))
+            ival = PyLong_AsUnsignedLongMask(arg);
+        else
+            return converterr("integer<k>", arg, msgbuf, bufsize);
+        *p = ival;
+        break;
+    }
+
 #ifdef HAVE_LONG_LONG
-	case 'L': {/* PY_LONG_LONG */
-		PY_LONG_LONG *p = va_arg( *p_va, PY_LONG_LONG * );
-		PY_LONG_LONG ival;
-		if (float_argument_warning(arg))
-			return converterr("long<L>", arg, msgbuf, bufsize);
-		ival = PyLong_AsLongLong(arg);
-		if (ival == (PY_LONG_LONG)-1 && PyErr_Occurred() ) {
-			return converterr("long<L>", arg, msgbuf, bufsize);
-		} else {
-			*p = ival;
-		}
-		break;
-	}
-
-	case 'K': { /* long long sized bitfield */
-		unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *);
-		unsigned PY_LONG_LONG ival;
-		if (PyInt_Check(arg))
-			ival = PyInt_AsUnsignedLongMask(arg);
-		else if (PyLong_Check(arg))
-			ival = PyLong_AsUnsignedLongLongMask(arg);
-		else
-			return converterr("integer<K>", arg, msgbuf, bufsize);
-		*p = ival;
-		break;
-	}
+    case 'L': {/* PY_LONG_LONG */
+        PY_LONG_LONG *p = va_arg( *p_va, PY_LONG_LONG * );
+        PY_LONG_LONG ival;
+        if (float_argument_warning(arg))
+            return converterr("long<L>", arg, msgbuf, bufsize);
+        ival = PyLong_AsLongLong(arg);
+        if (ival == (PY_LONG_LONG)-1 && PyErr_Occurred() ) {
+            return converterr("long<L>", arg, msgbuf, bufsize);
+        } else {
+            *p = ival;
+        }
+        break;
+    }
+
+    case 'K': { /* long long sized bitfield */
+        unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *);
+        unsigned PY_LONG_LONG ival;
+        if (PyInt_Check(arg))
+            ival = PyInt_AsUnsignedLongMask(arg);
+        else if (PyLong_Check(arg))
+            ival = PyLong_AsUnsignedLongLongMask(arg);
+        else
+            return converterr("integer<K>", arg, msgbuf, bufsize);
+        *p = ival;
+        break;
+    }
 #endif
-	
-	case 'f': {/* float */
-		float *p = va_arg(*p_va, float *);
-		double dval = PyFloat_AsDouble(arg);
-		if (PyErr_Occurred())
-			return converterr("float<f>", arg, msgbuf, bufsize);
-		else
-			*p = (float) dval;
-		break;
-	}
-	
-	case 'd': {/* double */
-		double *p = va_arg(*p_va, double *);
-		double dval = PyFloat_AsDouble(arg);
-		if (PyErr_Occurred())
-			return converterr("float<d>", arg, msgbuf, bufsize);
-		else
-			*p = dval;
-		break;
-	}
-	
+
+    case 'f': {/* float */
+        float *p = va_arg(*p_va, float *);
+        double dval = PyFloat_AsDouble(arg);
+        if (PyErr_Occurred())
+            return converterr("float<f>", arg, msgbuf, bufsize);
+        else
+            *p = (float) dval;
+        break;
+    }
+
+    case 'd': {/* double */
+        double *p = va_arg(*p_va, double *);
+        double dval = PyFloat_AsDouble(arg);
+        if (PyErr_Occurred())
+            return converterr("float<d>", arg, msgbuf, bufsize);
+        else
+            *p = dval;
+        break;
+    }
+
 #ifndef WITHOUT_COMPLEX
-	case 'D': {/* complex double */
-		Py_complex *p = va_arg(*p_va, Py_complex *);
-		Py_complex cval;
-		cval = PyComplex_AsCComplex(arg);
-		if (PyErr_Occurred())
-			return converterr("complex<D>", arg, msgbuf, bufsize);
-		else
-			*p = cval;
-		break;
-	}
+    case 'D': {/* complex double */
+        Py_complex *p = va_arg(*p_va, Py_complex *);
+        Py_complex cval;
+        cval = PyComplex_AsCComplex(arg);
+        if (PyErr_Occurred())
+            return converterr("complex<D>", arg, msgbuf, bufsize);
+        else
+            *p = cval;
+        break;
+    }
 #endif /* WITHOUT_COMPLEX */
-	
-	case 'c': {/* char */
-		char *p = va_arg(*p_va, char *);
-		if (PyString_Check(arg) && PyString_Size(arg) == 1)
-			*p = PyString_AS_STRING(arg)[0];
-		else
-			return converterr("char", arg, msgbuf, bufsize);
-		break;
-	}
-	
-	case 's': {/* string */
-		if (*format == '*') {
-			Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
-
-			if (PyString_Check(arg)) {
-				PyBuffer_FillInfo(p, arg,
-						  PyString_AS_STRING(arg), PyString_GET_SIZE(arg),
-						  1, 0);
-			}
+
+    case 'c': {/* char */
+        char *p = va_arg(*p_va, char *);
+        if (PyString_Check(arg) && PyString_Size(arg) == 1)
+            *p = PyString_AS_STRING(arg)[0];
+        else
+            return converterr("char", arg, msgbuf, bufsize);
+        break;
+    }
+
+    case 's': {/* string */
+        if (*format == '*') {
+            Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
+
+            if (PyString_Check(arg)) {
+                PyBuffer_FillInfo(p, arg,
+                                  PyString_AS_STRING(arg), PyString_GET_SIZE(arg),
+                                  1, 0);
+            }
 #ifdef Py_USING_UNICODE
-			else if (PyUnicode_Check(arg)) {
-				uarg = UNICODE_DEFAULT_ENCODING(arg);
-				if (uarg == NULL)
-					return converterr(CONV_UNICODE,
-							  arg, msgbuf, bufsize);
-				PyBuffer_FillInfo(p, arg,
-						  PyString_AS_STRING(uarg), PyString_GET_SIZE(uarg),
-						  1, 0);
-			}
+            else if (PyUnicode_Check(arg)) {
+                uarg = UNICODE_DEFAULT_ENCODING(arg);
+                if (uarg == NULL)
+                    return converterr(CONV_UNICODE,
+                                      arg, msgbuf, bufsize);
+                PyBuffer_FillInfo(p, arg,
+                                  PyString_AS_STRING(uarg), PyString_GET_SIZE(uarg),
+                                  1, 0);
+            }
 #endif
-			else { /* any buffer-like object */
-				char *buf;
-				if (getbuffer(arg, p, &buf) < 0)
-					return converterr(buf, arg, msgbuf, bufsize);
-			}
-			if (addcleanup(p, freelist, cleanup_buffer)) {
-				return converterr(
-					"(cleanup problem)",
-					arg, msgbuf, bufsize);
-			}
-			format++;
-		} else if (*format == '#') {
-			void **p = (void **)va_arg(*p_va, char **);
-			FETCH_SIZE;
-			
-			if (PyString_Check(arg)) {
-				*p = PyString_AS_STRING(arg);
-				STORE_SIZE(PyString_GET_SIZE(arg));
-			}
+            else { /* any buffer-like object */
+                char *buf;
+                if (getbuffer(arg, p, &buf) < 0)
+                    return converterr(buf, arg, msgbuf, bufsize);
+            }
+            if (addcleanup(p, freelist, cleanup_buffer)) {
+                return converterr(
+                    "(cleanup problem)",
+                    arg, msgbuf, bufsize);
+            }
+            format++;
+        } else if (*format == '#') {
+            void **p = (void **)va_arg(*p_va, char **);
+            FETCH_SIZE;
+
+            if (PyString_Check(arg)) {
+                *p = PyString_AS_STRING(arg);
+                STORE_SIZE(PyString_GET_SIZE(arg));
+            }
 #ifdef Py_USING_UNICODE
-			else if (PyUnicode_Check(arg)) {
-				uarg = UNICODE_DEFAULT_ENCODING(arg);
-				if (uarg == NULL)
-					return converterr(CONV_UNICODE,
-							  arg, msgbuf, bufsize);
-				*p = PyString_AS_STRING(uarg);
-				STORE_SIZE(PyString_GET_SIZE(uarg));
-			}
+            else if (PyUnicode_Check(arg)) {
+                uarg = UNICODE_DEFAULT_ENCODING(arg);
+                if (uarg == NULL)
+                    return converterr(CONV_UNICODE,
+                                      arg, msgbuf, bufsize);
+                *p = PyString_AS_STRING(uarg);
+                STORE_SIZE(PyString_GET_SIZE(uarg));
+            }
 #endif
-			else { /* any buffer-like object */
-				char *buf;
-				Py_ssize_t count = convertbuffer(arg, p, &buf);
-				if (count < 0)
-					return converterr(buf, arg, msgbuf, bufsize);
-				STORE_SIZE(count);
-			}
-			format++;
-		} else {
-			char **p = va_arg(*p_va, char **);
-			
-			if (PyString_Check(arg))
-				*p = PyString_AS_STRING(arg);
+            else { /* any buffer-like object */
+                char *buf;
+                Py_ssize_t count = convertbuffer(arg, p, &buf);
+                if (count < 0)
+                    return converterr(buf, arg, msgbuf, bufsize);
+                STORE_SIZE(count);
+            }
+            format++;
+        } else {
+            char **p = va_arg(*p_va, char **);
+
+            if (PyString_Check(arg))
+                *p = PyString_AS_STRING(arg);
 #ifdef Py_USING_UNICODE
-			else if (PyUnicode_Check(arg)) {
-				uarg = UNICODE_DEFAULT_ENCODING(arg);
-				if (uarg == NULL)
-					return converterr(CONV_UNICODE,
-							  arg, msgbuf, bufsize);
-				*p = PyString_AS_STRING(uarg);
-			}
+            else if (PyUnicode_Check(arg)) {
+                uarg = UNICODE_DEFAULT_ENCODING(arg);
+                if (uarg == NULL)
+                    return converterr(CONV_UNICODE,
+                                      arg, msgbuf, bufsize);
+                *p = PyString_AS_STRING(uarg);
+            }
 #endif
-			else
-				return converterr("string", arg, msgbuf, bufsize);
-			if ((Py_ssize_t)strlen(*p) != PyString_Size(arg))
-				return converterr("string without null bytes",
-						  arg, msgbuf, bufsize);
-		}
-		break;
-	}
-
-	case 'z': {/* string, may be NULL (None) */
-		if (*format == '*') {
-			Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
-
-			if (arg == Py_None)
-				PyBuffer_FillInfo(p, NULL, NULL, 0, 1, 0);
-			else if (PyString_Check(arg)) {
-				PyBuffer_FillInfo(p, arg,
-						  PyString_AS_STRING(arg), PyString_GET_SIZE(arg),
-						  1, 0);
-			}
+            else
+                return converterr("string", arg, msgbuf, bufsize);
+            if ((Py_ssize_t)strlen(*p) != PyString_Size(arg))
+                return converterr("string without null bytes",
+                                  arg, msgbuf, bufsize);
+        }
+        break;
+    }
+
+    case 'z': {/* string, may be NULL (None) */
+        if (*format == '*') {
+            Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
+
+            if (arg == Py_None)
+                PyBuffer_FillInfo(p, NULL, NULL, 0, 1, 0);
+            else if (PyString_Check(arg)) {
+                PyBuffer_FillInfo(p, arg,
+                                  PyString_AS_STRING(arg), PyString_GET_SIZE(arg),
+                                  1, 0);
+            }
 #ifdef Py_USING_UNICODE
-			else if (PyUnicode_Check(arg)) {
-				uarg = UNICODE_DEFAULT_ENCODING(arg);
-				if (uarg == NULL)
-					return converterr(CONV_UNICODE,
-							  arg, msgbuf, bufsize);
-				PyBuffer_FillInfo(p, arg,
-						  PyString_AS_STRING(uarg), PyString_GET_SIZE(uarg),
-						  1, 0);
-			}
+            else if (PyUnicode_Check(arg)) {
+                uarg = UNICODE_DEFAULT_ENCODING(arg);
+                if (uarg == NULL)
+                    return converterr(CONV_UNICODE,
+                                      arg, msgbuf, bufsize);
+                PyBuffer_FillInfo(p, arg,
+                                  PyString_AS_STRING(uarg), PyString_GET_SIZE(uarg),
+                                  1, 0);
+            }
 #endif
-			else { /* any buffer-like object */
-				char *buf;
-				if (getbuffer(arg, p, &buf) < 0)
-					return converterr(buf, arg, msgbuf, bufsize);
-			}
-			if (addcleanup(p, freelist, cleanup_buffer)) {
-				return converterr(
-					"(cleanup problem)",
-					arg, msgbuf, bufsize);
-			}
-			format++;
-		} else if (*format == '#') { /* any buffer-like object */
-			void **p = (void **)va_arg(*p_va, char **);
-			FETCH_SIZE;
-			
-			if (arg == Py_None) {
-				*p = 0;
-				STORE_SIZE(0);
-			}
-			else if (PyString_Check(arg)) {
-				*p = PyString_AS_STRING(arg);
-				STORE_SIZE(PyString_GET_SIZE(arg));
-			}
+            else { /* any buffer-like object */
+                char *buf;
+                if (getbuffer(arg, p, &buf) < 0)
+                    return converterr(buf, arg, msgbuf, bufsize);
+            }
+            if (addcleanup(p, freelist, cleanup_buffer)) {
+                return converterr(
+                    "(cleanup problem)",
+                    arg, msgbuf, bufsize);
+            }
+            format++;
+        } else if (*format == '#') { /* any buffer-like object */
+            void **p = (void **)va_arg(*p_va, char **);
+            FETCH_SIZE;
+
+            if (arg == Py_None) {
+                *p = 0;
+                STORE_SIZE(0);
+            }
+            else if (PyString_Check(arg)) {
+                *p = PyString_AS_STRING(arg);
+                STORE_SIZE(PyString_GET_SIZE(arg));
+            }
 #ifdef Py_USING_UNICODE
-			else if (PyUnicode_Check(arg)) {
-				uarg = UNICODE_DEFAULT_ENCODING(arg);
-				if (uarg == NULL)
-					return converterr(CONV_UNICODE,
-							  arg, msgbuf, bufsize);
-				*p = PyString_AS_STRING(uarg);
-				STORE_SIZE(PyString_GET_SIZE(uarg));
-			}
+            else if (PyUnicode_Check(arg)) {
+                uarg = UNICODE_DEFAULT_ENCODING(arg);
+                if (uarg == NULL)
+                    return converterr(CONV_UNICODE,
+                                      arg, msgbuf, bufsize);
+                *p = PyString_AS_STRING(uarg);
+                STORE_SIZE(PyString_GET_SIZE(uarg));
+            }
 #endif
-			else { /* any buffer-like object */
-				char *buf;
-				Py_ssize_t count = convertbuffer(arg, p, &buf);
-				if (count < 0)
-					return converterr(buf, arg, msgbuf, bufsize);
-				STORE_SIZE(count);
-			}
-			format++;
-		} else {
-			char **p = va_arg(*p_va, char **);
-			
-			if (arg == Py_None)
-				*p = 0;
-			else if (PyString_Check(arg))
-				*p = PyString_AS_STRING(arg);
+            else { /* any buffer-like object */
+                char *buf;
+                Py_ssize_t count = convertbuffer(arg, p, &buf);
+                if (count < 0)
+                    return converterr(buf, arg, msgbuf, bufsize);
+                STORE_SIZE(count);
+            }
+            format++;
+        } else {
+            char **p = va_arg(*p_va, char **);
+
+            if (arg == Py_None)
+                *p = 0;
+            else if (PyString_Check(arg))
+                *p = PyString_AS_STRING(arg);
 #ifdef Py_USING_UNICODE
-			else if (PyUnicode_Check(arg)) {
-				uarg = UNICODE_DEFAULT_ENCODING(arg);
-				if (uarg == NULL)
-					return converterr(CONV_UNICODE,
-							  arg, msgbuf, bufsize);
-				*p = PyString_AS_STRING(uarg);
-			}
+            else if (PyUnicode_Check(arg)) {
+                uarg = UNICODE_DEFAULT_ENCODING(arg);
+                if (uarg == NULL)
+                    return converterr(CONV_UNICODE,
+                                      arg, msgbuf, bufsize);
+                *p = PyString_AS_STRING(uarg);
+            }
 #endif
-			else
-				return converterr("string or None", 
-						  arg, msgbuf, bufsize);
-			if (*format == '#') {
-				FETCH_SIZE;
-				assert(0); /* XXX redundant with if-case */
-				if (arg == Py_None)
-					*q = 0;
-				else
-					*q = PyString_Size(arg);
-				format++;
-			}
-			else if (*p != NULL &&
-				 (Py_ssize_t)strlen(*p) != PyString_Size(arg))
-				return converterr(
-					"string without null bytes or None", 
-					arg, msgbuf, bufsize);
-		}
-		break;
-	}
-	
-	case 'e': {/* encoded string */
-		char **buffer;
-		const char *encoding;
-		PyObject *s;
-		Py_ssize_t size;
-		int recode_strings;
-
-		/* Get 'e' parameter: the encoding name */
-		encoding = (const char *)va_arg(*p_va, const char *);
+            else
+                return converterr("string or None",
+                                  arg, msgbuf, bufsize);
+            if (*format == '#') {
+                FETCH_SIZE;
+                assert(0); /* XXX redundant with if-case */
+                if (arg == Py_None)
+                    *q = 0;
+                else
+                    *q = PyString_Size(arg);
+                format++;
+            }
+            else if (*p != NULL &&
+                     (Py_ssize_t)strlen(*p) != PyString_Size(arg))
+                return converterr(
+                    "string without null bytes or None",
+                    arg, msgbuf, bufsize);
+        }
+        break;
+    }
+
+    case 'e': {/* encoded string */
+        char **buffer;
+        const char *encoding;
+        PyObject *s;
+        Py_ssize_t size;
+        int recode_strings;
+
+        /* Get 'e' parameter: the encoding name */
+        encoding = (const char *)va_arg(*p_va, const char *);
 #ifdef Py_USING_UNICODE
-		if (encoding == NULL)
-			encoding = PyUnicode_GetDefaultEncoding();
+        if (encoding == NULL)
+            encoding = PyUnicode_GetDefaultEncoding();
 #endif
-			
-		/* Get output buffer parameter:
-		   's' (recode all objects via Unicode) or
-		   't' (only recode non-string objects) 
-		*/
-		if (*format == 's')
-			recode_strings = 1;
-		else if (*format == 't')
-			recode_strings = 0;
-		else
-			return converterr(
-				"(unknown parser marker combination)",
-				arg, msgbuf, bufsize);
-		buffer = (char **)va_arg(*p_va, char **);
-		format++;
-		if (buffer == NULL)
-			return converterr("(buffer is NULL)", 
-					  arg, msgbuf, bufsize);
-			
-		/* Encode object */
-		if (!recode_strings && PyString_Check(arg)) {
-			s = arg;
-			Py_INCREF(s);
-		}
-		else {
+
+        /* Get output buffer parameter:
+           's' (recode all objects via Unicode) or
+           't' (only recode non-string objects)
+        */
+        if (*format == 's')
+            recode_strings = 1;
+        else if (*format == 't')
+            recode_strings = 0;
+        else
+            return converterr(
+                "(unknown parser marker combination)",
+                arg, msgbuf, bufsize);
+        buffer = (char **)va_arg(*p_va, char **);
+        format++;
+        if (buffer == NULL)
+            return converterr("(buffer is NULL)",
+                              arg, msgbuf, bufsize);
+
+        /* Encode object */
+        if (!recode_strings && PyString_Check(arg)) {
+            s = arg;
+            Py_INCREF(s);
+        }
+        else {
 #ifdef Py_USING_UNICODE
-		    	PyObject *u;
-
-			/* Convert object to Unicode */
-			u = PyUnicode_FromObject(arg);
-			if (u == NULL)
-				return converterr(
-					"string or unicode or text buffer", 
-					arg, msgbuf, bufsize);
-			
-			/* Encode object; use default error handling */
-			s = PyUnicode_AsEncodedString(u,
-						      encoding,
-						      NULL);
-			Py_DECREF(u);
-			if (s == NULL)
-				return converterr("(encoding failed)",
-						  arg, msgbuf, bufsize);
-			if (!PyString_Check(s)) {
-				Py_DECREF(s);
-				return converterr(
-					"(encoder failed to return a string)",
-					arg, msgbuf, bufsize);
-			}
+            PyObject *u;
+
+            /* Convert object to Unicode */
+            u = PyUnicode_FromObject(arg);
+            if (u == NULL)
+                return converterr(
+                    "string or unicode or text buffer",
+                    arg, msgbuf, bufsize);
+
+            /* Encode object; use default error handling */
+            s = PyUnicode_AsEncodedString(u,
+                                          encoding,
+                                          NULL);
+            Py_DECREF(u);
+            if (s == NULL)
+                return converterr("(encoding failed)",
+                                  arg, msgbuf, bufsize);
+            if (!PyString_Check(s)) {
+                Py_DECREF(s);
+                return converterr(
+                    "(encoder failed to return a string)",
+                    arg, msgbuf, bufsize);
+            }
 #else
-			return converterr("string<e>", arg, msgbuf, bufsize);
+            return converterr("string<e>", arg, msgbuf, bufsize);
 #endif
-		}
-		size = PyString_GET_SIZE(s);
-
-		/* Write output; output is guaranteed to be 0-terminated */
-		if (*format == '#') { 
-			/* Using buffer length parameter '#':
-				   
-			   - if *buffer is NULL, a new buffer of the
-			   needed size is allocated and the data
-			   copied into it; *buffer is updated to point
-			   to the new buffer; the caller is
-			   responsible for PyMem_Free()ing it after
-			   usage 
-
-			   - if *buffer is not NULL, the data is
-			   copied to *buffer; *buffer_len has to be
-			   set to the size of the buffer on input;
-			   buffer overflow is signalled with an error;
-			   buffer has to provide enough room for the
-			   encoded string plus the trailing 0-byte
-			   
-			   - in both cases, *buffer_len is updated to
-			   the size of the buffer /excluding/ the
-			   trailing 0-byte 
-			   
-			*/
-			FETCH_SIZE;
-
-			format++;
-			if (q == NULL && q2 == NULL) {
-				Py_DECREF(s);
-				return converterr(
-					"(buffer_len is NULL)",
-					arg, msgbuf, bufsize);
-			}
-			if (*buffer == NULL) {
-				*buffer = PyMem_NEW(char, size + 1);
-				if (*buffer == NULL) {
-					Py_DECREF(s);
-					return converterr(
-						"(memory error)",
-						arg, msgbuf, bufsize);
-				}
-				if (addcleanup(*buffer, freelist, cleanup_ptr)) {
-					Py_DECREF(s);
-					return converterr(
-						"(cleanup problem)",
-						arg, msgbuf, bufsize);
-				}
-			} else {
-				if (size + 1 > BUFFER_LEN) {
-					Py_DECREF(s);
-					return converterr(
-						"(buffer overflow)", 
-						arg, msgbuf, bufsize);
-				}
-			}
-			memcpy(*buffer,
-			       PyString_AS_STRING(s),
-			       size + 1);
-			STORE_SIZE(size);
-		} else {
-			/* Using a 0-terminated buffer:
-				   
-			   - the encoded string has to be 0-terminated
-			   for this variant to work; if it is not, an
-			   error raised 
-
-			   - a new buffer of the needed size is
-			   allocated and the data copied into it;
-			   *buffer is updated to point to the new
-			   buffer; the caller is responsible for
-			   PyMem_Free()ing it after usage
-
-			*/
-			if ((Py_ssize_t)strlen(PyString_AS_STRING(s))
-								!= size) {
-				Py_DECREF(s);
-				return converterr(
-					"encoded string without NULL bytes",
-					arg, msgbuf, bufsize);
-			}
-			*buffer = PyMem_NEW(char, size + 1);
-			if (*buffer == NULL) {
-				Py_DECREF(s);
-				return converterr("(memory error)",
-						  arg, msgbuf, bufsize);
-			}
-			if (addcleanup(*buffer, freelist, cleanup_ptr)) {
-				Py_DECREF(s);
-				return converterr("(cleanup problem)",
-						arg, msgbuf, bufsize);
-			}
-			memcpy(*buffer,
-			       PyString_AS_STRING(s),
-			       size + 1);
-		}
-		Py_DECREF(s);
-		break;
-	}
+        }
+        size = PyString_GET_SIZE(s);
+
+        /* Write output; output is guaranteed to be 0-terminated */
+        if (*format == '#') {
+            /* Using buffer length parameter '#':
+
+               - if *buffer is NULL, a new buffer of the
+               needed size is allocated and the data
+               copied into it; *buffer is updated to point
+               to the new buffer; the caller is
+               responsible for PyMem_Free()ing it after
+               usage
+
+               - if *buffer is not NULL, the data is
+               copied to *buffer; *buffer_len has to be
+               set to the size of the buffer on input;
+               buffer overflow is signalled with an error;
+               buffer has to provide enough room for the
+               encoded string plus the trailing 0-byte
+
+               - in both cases, *buffer_len is updated to
+               the size of the buffer /excluding/ the
+               trailing 0-byte
+
+            */
+            FETCH_SIZE;
+
+            format++;
+            if (q == NULL && q2 == NULL) {
+                Py_DECREF(s);
+                return converterr(
+                    "(buffer_len is NULL)",
+                    arg, msgbuf, bufsize);
+            }
+            if (*buffer == NULL) {
+                *buffer = PyMem_NEW(char, size + 1);
+                if (*buffer == NULL) {
+                    Py_DECREF(s);
+                    return converterr(
+                        "(memory error)",
+                        arg, msgbuf, bufsize);
+                }
+                if (addcleanup(*buffer, freelist, cleanup_ptr)) {
+                    Py_DECREF(s);
+                    return converterr(
+                        "(cleanup problem)",
+                        arg, msgbuf, bufsize);
+                }
+            } else {
+                if (size + 1 > BUFFER_LEN) {
+                    Py_DECREF(s);
+                    return converterr(
+                        "(buffer overflow)",
+                        arg, msgbuf, bufsize);
+                }
+            }
+            memcpy(*buffer,
+                   PyString_AS_STRING(s),
+                   size + 1);
+            STORE_SIZE(size);
+        } else {
+            /* Using a 0-terminated buffer:
+
+               - the encoded string has to be 0-terminated
+               for this variant to work; if it is not, an
+               error raised
+
+               - a new buffer of the needed size is
+               allocated and the data copied into it;
+               *buffer is updated to point to the new
+               buffer; the caller is responsible for
+               PyMem_Free()ing it after usage
+
+            */
+            if ((Py_ssize_t)strlen(PyString_AS_STRING(s))
+                                                    != size) {
+                Py_DECREF(s);
+                return converterr(
+                    "encoded string without NULL bytes",
+                    arg, msgbuf, bufsize);
+            }
+            *buffer = PyMem_NEW(char, size + 1);
+            if (*buffer == NULL) {
+                Py_DECREF(s);
+                return converterr("(memory error)",
+                                  arg, msgbuf, bufsize);
+            }
+            if (addcleanup(*buffer, freelist, cleanup_ptr)) {
+                Py_DECREF(s);
+                return converterr("(cleanup problem)",
+                                arg, msgbuf, bufsize);
+            }
+            memcpy(*buffer,
+                   PyString_AS_STRING(s),
+                   size + 1);
+        }
+        Py_DECREF(s);
+        break;
+    }
 
 #ifdef Py_USING_UNICODE
-	case 'u': {/* raw unicode buffer (Py_UNICODE *) */
-		if (*format == '#') { /* any buffer-like object */
-			void **p = (void **)va_arg(*p_va, char **);
-			FETCH_SIZE;
-			if (PyUnicode_Check(arg)) {
-			    	*p = PyUnicode_AS_UNICODE(arg);
-				STORE_SIZE(PyUnicode_GET_SIZE(arg));
-			}
-			else {
-				return converterr("cannot convert raw buffers",
-						  arg, msgbuf, bufsize);
-			}
-			format++;
-		} else {
-			Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
-			if (PyUnicode_Check(arg))
-				*p = PyUnicode_AS_UNICODE(arg);
-			else
-				return converterr("unicode", arg, msgbuf, bufsize);
-		}
-		break;
-	}
+    case 'u': {/* raw unicode buffer (Py_UNICODE *) */
+        if (*format == '#') { /* any buffer-like object */
+            void **p = (void **)va_arg(*p_va, char **);
+            FETCH_SIZE;
+            if (PyUnicode_Check(arg)) {
+                *p = PyUnicode_AS_UNICODE(arg);
+                STORE_SIZE(PyUnicode_GET_SIZE(arg));
+            }
+            else {
+                return converterr("cannot convert raw buffers",
+                                  arg, msgbuf, bufsize);
+            }
+            format++;
+        } else {
+            Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
+            if (PyUnicode_Check(arg))
+                *p = PyUnicode_AS_UNICODE(arg);
+            else
+                return converterr("unicode", arg, msgbuf, bufsize);
+        }
+        break;
+    }
 #endif
 
-	case 'S': { /* string object */
-		PyObject **p = va_arg(*p_va, PyObject **);
-		if (PyString_Check(arg))
-			*p = arg;
-		else
-			return converterr("string", arg, msgbuf, bufsize);
-		break;
-	}
-	
+    case 'S': { /* string object */
+        PyObject **p = va_arg(*p_va, PyObject **);
+        if (PyString_Check(arg))
+            *p = arg;
+        else
+            return converterr("string", arg, msgbuf, bufsize);
+        break;
+    }
+
 #ifdef Py_USING_UNICODE
-	case 'U': { /* Unicode object */
-		PyObject **p = va_arg(*p_va, PyObject **);
-		if (PyUnicode_Check(arg))
-			*p = arg;
-		else
-			return converterr("unicode", arg, msgbuf, bufsize);
-		break;
-	}
+    case 'U': { /* Unicode object */
+        PyObject **p = va_arg(*p_va, PyObject **);
+        if (PyUnicode_Check(arg))
+            *p = arg;
+        else
+            return converterr("unicode", arg, msgbuf, bufsize);
+        break;
+    }
 #endif
-	
-	case 'O': { /* object */
-		PyTypeObject *type;
-		PyObject **p;
-		if (*format == '!') {
-			type = va_arg(*p_va, PyTypeObject*);
-			p = va_arg(*p_va, PyObject **);
-			format++;
-			if (PyType_IsSubtype(arg->ob_type, type))
-				*p = arg;
-			else
-				return converterr(type->tp_name, arg, msgbuf, bufsize);
-
-		}
-		else if (*format == '?') {
-			inquiry pred = va_arg(*p_va, inquiry);
-			p = va_arg(*p_va, PyObject **);
-			format++;
-			if ((*pred)(arg)) 
-				*p = arg;
-			else
-				return converterr("(unspecified)", 
-						  arg, msgbuf, bufsize);
-				
-		}
-		else if (*format == '&') {
-			typedef int (*converter)(PyObject *, void *);
-			converter convert = va_arg(*p_va, converter);
-			void *addr = va_arg(*p_va, void *);
-			format++;
-			if (! (*convert)(arg, addr))
-				return converterr("(unspecified)", 
-						  arg, msgbuf, bufsize);
-		}
-		else {
-			p = va_arg(*p_va, PyObject **);
-			*p = arg;
-		}
-		break;
-	}
-		
-		
-	case 'w': { /* memory buffer, read-write access */
-		void **p = va_arg(*p_va, void **);
-		void *res;
-		PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
-		Py_ssize_t count;
-
-		if (pb && pb->bf_releasebuffer && *format != '*')
-			/* Buffer must be released, yet caller does not use
-			   the Py_buffer protocol. */
-			return converterr("pinned buffer", arg, msgbuf, bufsize);
-
-		if (pb && pb->bf_getbuffer && *format == '*') {
-			/* Caller is interested in Py_buffer, and the object
-			   supports it directly. */
-			format++;
-			if (pb->bf_getbuffer(arg, (Py_buffer*)p, PyBUF_WRITABLE) < 0) {
-				PyErr_Clear();
-				return converterr("read-write buffer", arg, msgbuf, bufsize);
-			}
-			if (addcleanup(p, freelist, cleanup_buffer)) {
-				return converterr(
-					"(cleanup problem)",
-					arg, msgbuf, bufsize);
-			}
-			if (!PyBuffer_IsContiguous((Py_buffer*)p, 'C'))
-				return converterr("contiguous buffer", arg, msgbuf, bufsize);
-			break;
-		}
-
-		if (pb == NULL ||
-		    pb->bf_getwritebuffer == NULL ||
-		    pb->bf_getsegcount == NULL)
-			return converterr("read-write buffer", arg, msgbuf, bufsize);
-		if ((*pb->bf_getsegcount)(arg, NULL) != 1)
-			return converterr("single-segment read-write buffer", 
-					  arg, msgbuf, bufsize);
-		if ((count = pb->bf_getwritebuffer(arg, 0, &res)) < 0)
-			return converterr("(unspecified)", arg, msgbuf, bufsize);
-		if (*format == '*') {
-			PyBuffer_FillInfo((Py_buffer*)p, arg, res, count, 1, 0);
-			format++;
-		}
-		else {
-			*p = res;
-			if (*format == '#') {
-				FETCH_SIZE;
-				STORE_SIZE(count);
-				format++;
-			}
-		}
-		break;
-	}
-		
-	case 't': { /* 8-bit character buffer, read-only access */
-		char **p = va_arg(*p_va, char **);
-		PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
-		Py_ssize_t count;
-		
-		if (*format++ != '#')
-			return converterr(
-				"invalid use of 't' format character", 
-				arg, msgbuf, bufsize);
-		if (!PyType_HasFeature(arg->ob_type,
-				       Py_TPFLAGS_HAVE_GETCHARBUFFER) ||
-		    pb == NULL || pb->bf_getcharbuffer == NULL ||
-		    pb->bf_getsegcount == NULL)
-			return converterr(
-				"string or read-only character buffer",
-				arg, msgbuf, bufsize);
-
-		if (pb->bf_getsegcount(arg, NULL) != 1)
-			return converterr(
-				"string or single-segment read-only buffer",
-				arg, msgbuf, bufsize);
-
-		if (pb->bf_releasebuffer)
-			return converterr(
-				"string or pinned buffer",
-				arg, msgbuf, bufsize);
-
-		count = pb->bf_getcharbuffer(arg, 0, p);
-		if (count < 0)
-			return converterr("(unspecified)", arg, msgbuf, bufsize);
-		{
-			FETCH_SIZE;
-			STORE_SIZE(count);
-		}
-		break;
-	}
-
-	default:
-		return converterr("impossible<bad format char>", arg, msgbuf, bufsize);
-	
-	}
-	
-	*p_format = format;
-	return NULL;
+
+    case 'O': { /* object */
+        PyTypeObject *type;
+        PyObject **p;
+        if (*format == '!') {
+            type = va_arg(*p_va, PyTypeObject*);
+            p = va_arg(*p_va, PyObject **);
+            format++;
+            if (PyType_IsSubtype(arg->ob_type, type))
+                *p = arg;
+            else
+                return converterr(type->tp_name, arg, msgbuf, bufsize);
+
+        }
+        else if (*format == '?') {
+            inquiry pred = va_arg(*p_va, inquiry);
+            p = va_arg(*p_va, PyObject **);
+            format++;
+            if ((*pred)(arg))
+                *p = arg;
+            else
+                return converterr("(unspecified)",
+                                  arg, msgbuf, bufsize);
+
+        }
+        else if (*format == '&') {
+            typedef int (*converter)(PyObject *, void *);
+            converter convert = va_arg(*p_va, converter);
+            void *addr = va_arg(*p_va, void *);
+            format++;
+            if (! (*convert)(arg, addr))
+                return converterr("(unspecified)",
+                                  arg, msgbuf, bufsize);
+        }
+        else {
+            p = va_arg(*p_va, PyObject **);
+            *p = arg;
+        }
+        break;
+    }
+
+
+    case 'w': { /* memory buffer, read-write access */
+        void **p = va_arg(*p_va, void **);
+        void *res;
+        PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
+        Py_ssize_t count;
+
+        if (pb && pb->bf_releasebuffer && *format != '*')
+            /* Buffer must be released, yet caller does not use
+               the Py_buffer protocol. */
+            return converterr("pinned buffer", arg, msgbuf, bufsize);
+
+        if (pb && pb->bf_getbuffer && *format == '*') {
+            /* Caller is interested in Py_buffer, and the object
+               supports it directly. */
+            format++;
+            if (pb->bf_getbuffer(arg, (Py_buffer*)p, PyBUF_WRITABLE) < 0) {
+                PyErr_Clear();
+                return converterr("read-write buffer", arg, msgbuf, bufsize);
+            }
+            if (addcleanup(p, freelist, cleanup_buffer)) {
+                return converterr(
+                    "(cleanup problem)",
+                    arg, msgbuf, bufsize);
+            }
+            if (!PyBuffer_IsContiguous((Py_buffer*)p, 'C'))
+                return converterr("contiguous buffer", arg, msgbuf, bufsize);
+            break;
+        }
+
+        if (pb == NULL ||
+            pb->bf_getwritebuffer == NULL ||
+            pb->bf_getsegcount == NULL)
+            return converterr("read-write buffer", arg, msgbuf, bufsize);
+        if ((*pb->bf_getsegcount)(arg, NULL) != 1)
+            return converterr("single-segment read-write buffer",
+                              arg, msgbuf, bufsize);
+        if ((count = pb->bf_getwritebuffer(arg, 0, &res)) < 0)
+            return converterr("(unspecified)", arg, msgbuf, bufsize);
+        if (*format == '*') {
+            PyBuffer_FillInfo((Py_buffer*)p, arg, res, count, 1, 0);
+            format++;
+        }
+        else {
+            *p = res;
+            if (*format == '#') {
+                FETCH_SIZE;
+                STORE_SIZE(count);
+                format++;
+            }
+        }
+        break;
+    }
+
+    case 't': { /* 8-bit character buffer, read-only access */
+        char **p = va_arg(*p_va, char **);
+        PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
+        Py_ssize_t count;
+
+        if (*format++ != '#')
+            return converterr(
+                "invalid use of 't' format character",
+                arg, msgbuf, bufsize);
+        if (!PyType_HasFeature(arg->ob_type,
+                               Py_TPFLAGS_HAVE_GETCHARBUFFER) ||
+            pb == NULL || pb->bf_getcharbuffer == NULL ||
+            pb->bf_getsegcount == NULL)
+            return converterr(
+                "string or read-only character buffer",
+                arg, msgbuf, bufsize);
+
+        if (pb->bf_getsegcount(arg, NULL) != 1)
+            return converterr(
+                "string or single-segment read-only buffer",
+                arg, msgbuf, bufsize);
+
+        if (pb->bf_releasebuffer)
+            return converterr(
+                "string or pinned buffer",
+                arg, msgbuf, bufsize);
+
+        count = pb->bf_getcharbuffer(arg, 0, p);
+        if (count < 0)
+            return converterr("(unspecified)", arg, msgbuf, bufsize);
+        {
+            FETCH_SIZE;
+            STORE_SIZE(count);
+        }
+        break;
+    }
+
+    default:
+        return converterr("impossible<bad format char>", arg, msgbuf, bufsize);
+
+    }
+
+    *p_format = format;
+    return NULL;
 }
 
 static Py_ssize_t
 convertbuffer(PyObject *arg, void **p, char **errmsg)
 {
-	PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
-	Py_ssize_t count;
-	if (pb == NULL ||
-	    pb->bf_getreadbuffer == NULL ||
-	    pb->bf_getsegcount == NULL ||
-	    pb->bf_releasebuffer != NULL) {
-		*errmsg = "string or read-only buffer";
-		return -1;
-	}
-	if ((*pb->bf_getsegcount)(arg, NULL) != 1) {
-		*errmsg = "string or single-segment read-only buffer";
-		return -1;
-	}
-	if ((count = (*pb->bf_getreadbuffer)(arg, 0, p)) < 0) {
-		*errmsg = "(unspecified)";
-	}
-	return count;
+    PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
+    Py_ssize_t count;
+    if (pb == NULL ||
+        pb->bf_getreadbuffer == NULL ||
+        pb->bf_getsegcount == NULL ||
+        pb->bf_releasebuffer != NULL) {
+        *errmsg = "string or read-only buffer";
+        return -1;
+    }
+    if ((*pb->bf_getsegcount)(arg, NULL) != 1) {
+        *errmsg = "string or single-segment read-only buffer";
+        return -1;
+    }
+    if ((count = (*pb->bf_getreadbuffer)(arg, 0, p)) < 0) {
+        *errmsg = "(unspecified)";
+    }
+    return count;
 }
 
 static int
 getbuffer(PyObject *arg, Py_buffer *view, char **errmsg)
 {
-	void *buf;
-	Py_ssize_t count;
-	PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
-	if (pb == NULL) {
-		*errmsg = "string or buffer";
-		return -1;
-	}
-	if (pb->bf_getbuffer) {
-		if (pb->bf_getbuffer(arg, view, 0) < 0) {
-			*errmsg = "convertible to a buffer";
-			return -1;
-		}
-		if (!PyBuffer_IsContiguous(view, 'C')) {
-			*errmsg = "contiguous buffer";
-			return -1;
-		}
-		return 0;
-	}
-
-	count = convertbuffer(arg, &buf, errmsg);
-	if (count < 0) {
-		*errmsg = "convertible to a buffer";
-		return count;
-	}
-	PyBuffer_FillInfo(view, NULL, buf, count, 1, 0);
-	return 0;
+    void *buf;
+    Py_ssize_t count;
+    PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
+    if (pb == NULL) {
+        *errmsg = "string or buffer";
+        return -1;
+    }
+    if (pb->bf_getbuffer) {
+        if (pb->bf_getbuffer(arg, view, 0) < 0) {
+            *errmsg = "convertible to a buffer";
+            return -1;
+        }
+        if (!PyBuffer_IsContiguous(view, 'C')) {
+            *errmsg = "contiguous buffer";
+            return -1;
+        }
+        return 0;
+    }
+
+    count = convertbuffer(arg, &buf, errmsg);
+    if (count < 0) {
+        *errmsg = "convertible to a buffer";
+        return count;
+    }
+    PyBuffer_FillInfo(view, NULL, buf, count, 1, 0);
+    return 0;
 }
 
 /* Support for keyword arguments donated by
@@ -1409,487 +1409,487 @@ getbuffer(PyObject *arg, Py_buffer *view, char **errmsg)
 /* Return false (0) for error, else true. */
 int
 PyArg_ParseTupleAndKeywords(PyObject *args,
-			    PyObject *keywords,
-			    const char *format, 
-			    char **kwlist, ...)
+                            PyObject *keywords,
+                            const char *format,
+                            char **kwlist, ...)
 {
-	int retval;
-	va_list va;
-
-	if ((args == NULL || !PyTuple_Check(args)) ||
-	    (keywords != NULL && !PyDict_Check(keywords)) ||
-	    format == NULL ||
-	    kwlist == NULL)
-	{
-		PyErr_BadInternalCall();
-		return 0;
-	}
-
-	va_start(va, kwlist);
-	retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0);	
-	va_end(va);
-	return retval;
+    int retval;
+    va_list va;
+
+    if ((args == NULL || !PyTuple_Check(args)) ||
+        (keywords != NULL && !PyDict_Check(keywords)) ||
+        format == NULL ||
+        kwlist == NULL)
+    {
+        PyErr_BadInternalCall();
+        return 0;
+    }
+
+    va_start(va, kwlist);
+    retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0);
+    va_end(va);
+    return retval;
 }
 
 int
 _PyArg_ParseTupleAndKeywords_SizeT(PyObject *args,
-				  PyObject *keywords,
-				  const char *format, 
-				  char **kwlist, ...)
+                                  PyObject *keywords,
+                                  const char *format,
+                                  char **kwlist, ...)
 {
-	int retval;
-	va_list va;
-
-	if ((args == NULL || !PyTuple_Check(args)) ||
-	    (keywords != NULL && !PyDict_Check(keywords)) ||
-	    format == NULL ||
-	    kwlist == NULL)
-	{
-		PyErr_BadInternalCall();
-		return 0;
-	}
-
-	va_start(va, kwlist);
-	retval = vgetargskeywords(args, keywords, format, 
-				  kwlist, &va, FLAG_SIZE_T);
-	va_end(va);
-	return retval;
+    int retval;
+    va_list va;
+
+    if ((args == NULL || !PyTuple_Check(args)) ||
+        (keywords != NULL && !PyDict_Check(keywords)) ||
+        format == NULL ||
+        kwlist == NULL)
+    {
+        PyErr_BadInternalCall();
+        return 0;
+    }
+
+    va_start(va, kwlist);
+    retval = vgetargskeywords(args, keywords, format,
+                              kwlist, &va, FLAG_SIZE_T);
+    va_end(va);
+    return retval;
 }
 
 
 int
 PyArg_VaParseTupleAndKeywords(PyObject *args,
                               PyObject *keywords,
-                              const char *format, 
+                              const char *format,
                               char **kwlist, va_list va)
 {
-	int retval;
-	va_list lva;
-
-	if ((args == NULL || !PyTuple_Check(args)) ||
-	    (keywords != NULL && !PyDict_Check(keywords)) ||
-	    format == NULL ||
-	    kwlist == NULL)
-	{
-		PyErr_BadInternalCall();
-		return 0;
-	}
+    int retval;
+    va_list lva;
+
+    if ((args == NULL || !PyTuple_Check(args)) ||
+        (keywords != NULL && !PyDict_Check(keywords)) ||
+        format == NULL ||
+        kwlist == NULL)
+    {
+        PyErr_BadInternalCall();
+        return 0;
+    }
 
 #ifdef VA_LIST_IS_ARRAY
-	memcpy(lva, va, sizeof(va_list));
+    memcpy(lva, va, sizeof(va_list));
 #else
 #ifdef __va_copy
-	__va_copy(lva, va);
+    __va_copy(lva, va);
 #else
-	lva = va;
+    lva = va;
 #endif
 #endif
 
-	retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0);	
-	return retval;
+    retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0);
+    return retval;
 }
 
 int
 _PyArg_VaParseTupleAndKeywords_SizeT(PyObject *args,
-				    PyObject *keywords,
-				    const char *format, 
-				    char **kwlist, va_list va)
+                                    PyObject *keywords,
+                                    const char *format,
+                                    char **kwlist, va_list va)
 {
-	int retval;
-	va_list lva;
-
-	if ((args == NULL || !PyTuple_Check(args)) ||
-	    (keywords != NULL && !PyDict_Check(keywords)) ||
-	    format == NULL ||
-	    kwlist == NULL)
-	{
-		PyErr_BadInternalCall();
-		return 0;
-	}
+    int retval;
+    va_list lva;
+
+    if ((args == NULL || !PyTuple_Check(args)) ||
+        (keywords != NULL && !PyDict_Check(keywords)) ||
+        format == NULL ||
+        kwlist == NULL)
+    {
+        PyErr_BadInternalCall();
+        return 0;
+    }
 
 #ifdef VA_LIST_IS_ARRAY
-	memcpy(lva, va, sizeof(va_list));
+    memcpy(lva, va, sizeof(va_list));
 #else
 #ifdef __va_copy
-	__va_copy(lva, va);
+    __va_copy(lva, va);
 #else
-	lva = va;
+    lva = va;
 #endif
 #endif
 
-	retval = vgetargskeywords(args, keywords, format, 
-				  kwlist, &lva, FLAG_SIZE_T);
-	return retval;
+    retval = vgetargskeywords(args, keywords, format,
+                              kwlist, &lva, FLAG_SIZE_T);
+    return retval;
 }
 
 #define IS_END_OF_FORMAT(c) (c == '\0' || c == ';' || c == ':')
 
 static int
 vgetargskeywords(PyObject *args, PyObject *keywords, const char *format,
-	         char **kwlist, va_list *p_va, int flags)
+                 char **kwlist, va_list *p_va, int flags)
 {
-	char msgbuf[512];
-	int levels[32];
-	const char *fname, *msg, *custom_msg, *keyword;
-	int min = INT_MAX;
-	int i, len, nargs, nkeywords;
-	PyObject *freelist = NULL, *current_arg;
-
-	assert(args != NULL && PyTuple_Check(args));
-	assert(keywords == NULL || PyDict_Check(keywords));
-	assert(format != NULL);
-	assert(kwlist != NULL);
-	assert(p_va != NULL);
-
-	/* grab the function name or custom error msg first (mutually exclusive) */
-	fname = strchr(format, ':');
-	if (fname) {
-		fname++;
-		custom_msg = NULL;
-	}
-	else {
-		custom_msg = strchr(format,';');
-		if (custom_msg)
-			custom_msg++;
-	}
-
-	/* scan kwlist and get greatest possible nbr of args */
-	for (len=0; kwlist[len]; len++)
-		continue;
-
-	nargs = PyTuple_GET_SIZE(args);
-	nkeywords = (keywords == NULL) ? 0 : PyDict_Size(keywords);
-	if (nargs + nkeywords > len) {
-		PyErr_Format(PyExc_TypeError, "%s%s takes at most %d "
-			     "argument%s (%d given)",
-			     (fname == NULL) ? "function" : fname,
-			     (fname == NULL) ? "" : "()",
-			     len,
-			     (len == 1) ? "" : "s",
-			     nargs + nkeywords);
-		return 0;
-	}
-
-	/* convert tuple args and keyword args in same loop, using kwlist to drive process */
-	for (i = 0; i < len; i++) {
-		keyword = kwlist[i];
-		if (*format == '|') {
-			min = i;
-			format++;
-		}
-		if (IS_END_OF_FORMAT(*format)) {
-			PyErr_Format(PyExc_RuntimeError,
-				     "More keyword list entries (%d) than "
-				     "format specifiers (%d)", len, i);
-			return cleanreturn(0, freelist);
-		}
-		current_arg = NULL;
-		if (nkeywords) {
-			current_arg = PyDict_GetItemString(keywords, keyword);
-		}
-		if (current_arg) {
-			--nkeywords;
-			if (i < nargs) {
-				/* arg present in tuple and in dict */
-				PyErr_Format(PyExc_TypeError,
-					     "Argument given by name ('%s') "
-					     "and position (%d)",
-					     keyword, i+1);
-				return cleanreturn(0, freelist);
-			}
-		}
-		else if (nkeywords && PyErr_Occurred())
-			return cleanreturn(0, freelist);
-		else if (i < nargs)
-			current_arg = PyTuple_GET_ITEM(args, i);
-			
-		if (current_arg) {
-			msg = convertitem(current_arg, &format, p_va, flags,
-				levels, msgbuf, sizeof(msgbuf), &freelist);
-			if (msg) {
-				seterror(i+1, msg, levels, fname, custom_msg);
-				return cleanreturn(0, freelist);
-			}
-			continue;
-		}
-
-		if (i < min) {
-			PyErr_Format(PyExc_TypeError, "Required argument "
-				     "'%s' (pos %d) not found",
-				     keyword, i+1);
-			return cleanreturn(0, freelist);
-		}
-		/* current code reports success when all required args
-		 * fulfilled and no keyword args left, with no further
-		 * validation. XXX Maybe skip this in debug build ?
-		 */
-		if (!nkeywords)
-			return cleanreturn(1, freelist);
-
-		/* We are into optional args, skip thru to any remaining
-		 * keyword args */
-		msg = skipitem(&format, p_va, flags);
-		if (msg) {
-			PyErr_Format(PyExc_RuntimeError, "%s: '%s'", msg,
-				     format);
-			return cleanreturn(0, freelist);
-		}
-	}
-
-	if (!IS_END_OF_FORMAT(*format) && *format != '|') {
-		PyErr_Format(PyExc_RuntimeError,
-			"more argument specifiers than keyword list entries "
-			"(remaining format:'%s')", format);
-		return cleanreturn(0, freelist);
-	}
-
-	/* make sure there are no extraneous keyword arguments */
-	if (nkeywords > 0) {
-		PyObject *key, *value;
-		Py_ssize_t pos = 0;
-		while (PyDict_Next(keywords, &pos, &key, &value)) {
-			int match = 0;
-			char *ks;
-			if (!PyString_Check(key)) {
-				PyErr_SetString(PyExc_TypeError, 
-					        "keywords must be strings");
-				return cleanreturn(0, freelist);
-			}
-			ks = PyString_AsString(key);
-			for (i = 0; i < len; i++) {
-				if (!strcmp(ks, kwlist[i])) {
-					match = 1;
-					break;
-				}
-			}
-			if (!match) {
-				PyErr_Format(PyExc_TypeError,
-					     "'%s' is an invalid keyword "
-					     "argument for this function",
-					     ks);
-				return cleanreturn(0, freelist);
-			}
-		}
-	}
-
-	return cleanreturn(1, freelist);
+    char msgbuf[512];
+    int levels[32];
+    const char *fname, *msg, *custom_msg, *keyword;
+    int min = INT_MAX;
+    int i, len, nargs, nkeywords;
+    PyObject *freelist = NULL, *current_arg;
+
+    assert(args != NULL && PyTuple_Check(args));
+    assert(keywords == NULL || PyDict_Check(keywords));
+    assert(format != NULL);
+    assert(kwlist != NULL);
+    assert(p_va != NULL);
+
+    /* grab the function name or custom error msg first (mutually exclusive) */
+    fname = strchr(format, ':');
+    if (fname) {
+        fname++;
+        custom_msg = NULL;
+    }
+    else {
+        custom_msg = strchr(format,';');
+        if (custom_msg)
+            custom_msg++;
+    }
+
+    /* scan kwlist and get greatest possible nbr of args */
+    for (len=0; kwlist[len]; len++)
+        continue;
+
+    nargs = PyTuple_GET_SIZE(args);
+    nkeywords = (keywords == NULL) ? 0 : PyDict_Size(keywords);
+    if (nargs + nkeywords > len) {
+        PyErr_Format(PyExc_TypeError, "%s%s takes at most %d "
+                     "argument%s (%d given)",
+                     (fname == NULL) ? "function" : fname,
+                     (fname == NULL) ? "" : "()",
+                     len,
+                     (len == 1) ? "" : "s",
+                     nargs + nkeywords);
+        return 0;
+    }
+
+    /* convert tuple args and keyword args in same loop, using kwlist to drive process */
+    for (i = 0; i < len; i++) {
+        keyword = kwlist[i];
+        if (*format == '|') {
+            min = i;
+            format++;
+        }
+        if (IS_END_OF_FORMAT(*format)) {
+            PyErr_Format(PyExc_RuntimeError,
+                         "More keyword list entries (%d) than "
+                         "format specifiers (%d)", len, i);
+            return cleanreturn(0, freelist);
+        }
+        current_arg = NULL;
+        if (nkeywords) {
+            current_arg = PyDict_GetItemString(keywords, keyword);
+        }
+        if (current_arg) {
+            --nkeywords;
+            if (i < nargs) {
+                /* arg present in tuple and in dict */
+                PyErr_Format(PyExc_TypeError,
+                             "Argument given by name ('%s') "
+                             "and position (%d)",
+                             keyword, i+1);
+                return cleanreturn(0, freelist);
+            }
+        }
+        else if (nkeywords && PyErr_Occurred())
+            return cleanreturn(0, freelist);
+        else if (i < nargs)
+            current_arg = PyTuple_GET_ITEM(args, i);
+
+        if (current_arg) {
+            msg = convertitem(current_arg, &format, p_va, flags,
+                levels, msgbuf, sizeof(msgbuf), &freelist);
+            if (msg) {
+                seterror(i+1, msg, levels, fname, custom_msg);
+                return cleanreturn(0, freelist);
+            }
+            continue;
+        }
+
+        if (i < min) {
+            PyErr_Format(PyExc_TypeError, "Required argument "
+                         "'%s' (pos %d) not found",
+                         keyword, i+1);
+            return cleanreturn(0, freelist);
+        }
+        /* current code reports success when all required args
+         * fulfilled and no keyword args left, with no further
+         * validation. XXX Maybe skip this in debug build ?
+         */
+        if (!nkeywords)
+            return cleanreturn(1, freelist);
+
+        /* We are into optional args, skip thru to any remaining
+         * keyword args */
+        msg = skipitem(&format, p_va, flags);
+        if (msg) {
+            PyErr_Format(PyExc_RuntimeError, "%s: '%s'", msg,
+                         format);
+            return cleanreturn(0, freelist);
+        }
+    }
+
+    if (!IS_END_OF_FORMAT(*format) && *format != '|') {
+        PyErr_Format(PyExc_RuntimeError,
+            "more argument specifiers than keyword list entries "
+            "(remaining format:'%s')", format);
+        return cleanreturn(0, freelist);
+    }
+
+    /* make sure there are no extraneous keyword arguments */
+    if (nkeywords > 0) {
+        PyObject *key, *value;
+        Py_ssize_t pos = 0;
+        while (PyDict_Next(keywords, &pos, &key, &value)) {
+            int match = 0;
+            char *ks;
+            if (!PyString_Check(key)) {
+                PyErr_SetString(PyExc_TypeError,
+                                "keywords must be strings");
+                return cleanreturn(0, freelist);
+            }
+            ks = PyString_AsString(key);
+            for (i = 0; i < len; i++) {
+                if (!strcmp(ks, kwlist[i])) {
+                    match = 1;
+                    break;
+                }
+            }
+            if (!match) {
+                PyErr_Format(PyExc_TypeError,
+                             "'%s' is an invalid keyword "
+                             "argument for this function",
+                             ks);
+                return cleanreturn(0, freelist);
+            }
+        }
+    }
+
+    return cleanreturn(1, freelist);
 }
 
 
 static char *
 skipitem(const char **p_format, va_list *p_va, int flags)
 {
-	const char *format = *p_format;
-	char c = *format++;
-	
-	switch (c) {
-
-	/* simple codes
-	 * The individual types (second arg of va_arg) are irrelevant */
-
-	case 'b': /* byte -- very short int */
-	case 'B': /* byte as bitfield */
-	case 'h': /* short int */
-	case 'H': /* short int as bitfield */
-	case 'i': /* int */
-	case 'I': /* int sized bitfield */
-	case 'l': /* long int */
-	case 'k': /* long int sized bitfield */
+    const char *format = *p_format;
+    char c = *format++;
+
+    switch (c) {
+
+    /* simple codes
+     * The individual types (second arg of va_arg) are irrelevant */
+
+    case 'b': /* byte -- very short int */
+    case 'B': /* byte as bitfield */
+    case 'h': /* short int */
+    case 'H': /* short int as bitfield */
+    case 'i': /* int */
+    case 'I': /* int sized bitfield */
+    case 'l': /* long int */
+    case 'k': /* long int sized bitfield */
 #ifdef HAVE_LONG_LONG
-	case 'L': /* PY_LONG_LONG */
-	case 'K': /* PY_LONG_LONG sized bitfield */
+    case 'L': /* PY_LONG_LONG */
+    case 'K': /* PY_LONG_LONG sized bitfield */
 #endif
-	case 'f': /* float */
-	case 'd': /* double */
+    case 'f': /* float */
+    case 'd': /* double */
 #ifndef WITHOUT_COMPLEX
-	case 'D': /* complex double */
+    case 'D': /* complex double */
 #endif
-	case 'c': /* char */
-		{
-			(void) va_arg(*p_va, void *);
-			break;
-		}
-
-	case 'n': /* Py_ssize_t */
-		{
-			(void) va_arg(*p_va, Py_ssize_t *);
-			break;
-		}
-	
-	/* string codes */
-		
-	case 'e': /* string with encoding */
-		{
-			(void) va_arg(*p_va, const char *);
-			if (!(*format == 's' || *format == 't'))
-				/* after 'e', only 's' and 't' is allowed */
-				goto err;
-			format++;
-			/* explicit fallthrough to string cases */
-		}
-	
-	case 's': /* string */
-	case 'z': /* string or None */
+    case 'c': /* char */
+        {
+            (void) va_arg(*p_va, void *);
+            break;
+        }
+
+    case 'n': /* Py_ssize_t */
+        {
+            (void) va_arg(*p_va, Py_ssize_t *);
+            break;
+        }
+
+    /* string codes */
+
+    case 'e': /* string with encoding */
+        {
+            (void) va_arg(*p_va, const char *);
+            if (!(*format == 's' || *format == 't'))
+                /* after 'e', only 's' and 't' is allowed */
+                goto err;
+            format++;
+            /* explicit fallthrough to string cases */
+        }
+
+    case 's': /* string */
+    case 'z': /* string or None */
 #ifdef Py_USING_UNICODE
-	case 'u': /* unicode string */
+    case 'u': /* unicode string */
 #endif
-	case 't': /* buffer, read-only */
-	case 'w': /* buffer, read-write */
-		{
-			(void) va_arg(*p_va, char **);
-			if (*format == '#') {
-				if (flags & FLAG_SIZE_T)
-					(void) va_arg(*p_va, Py_ssize_t *);
-				else
-					(void) va_arg(*p_va, int *);
-				format++;
-			} else if ((c == 's' || c == 'z') && *format == '*') {
-				format++;
-			}
-			break;
-		}
-
-	/* object codes */
-
-	case 'S': /* string object */
+    case 't': /* buffer, read-only */
+    case 'w': /* buffer, read-write */
+        {
+            (void) va_arg(*p_va, char **);
+            if (*format == '#') {
+                if (flags & FLAG_SIZE_T)
+                    (void) va_arg(*p_va, Py_ssize_t *);
+                else
+                    (void) va_arg(*p_va, int *);
+                format++;
+            } else if ((c == 's' || c == 'z') && *format == '*') {
+                format++;
+            }
+            break;
+        }
+
+    /* object codes */
+
+    case 'S': /* string object */
 #ifdef Py_USING_UNICODE
-	case 'U': /* unicode string object */
+    case 'U': /* unicode string object */
 #endif
-		{
-			(void) va_arg(*p_va, PyObject **);
-			break;
-		}
-	
-	case 'O': /* object */
-		{
-			if (*format == '!') {
-				format++;
-				(void) va_arg(*p_va, PyTypeObject*);
-				(void) va_arg(*p_va, PyObject **);
-			}
-			else if (*format == '&') {
-				typedef int (*converter)(PyObject *, void *);
-				(void) va_arg(*p_va, converter);
-				(void) va_arg(*p_va, void *);
-				format++;
-			}
-			else {
-				(void) va_arg(*p_va, PyObject **);
-			}
-			break;
-		}
-
-	case '(':	/* bypass tuple, not handled at all previously */
-		{
-			char *msg;
-			for (;;) {
-				if (*format==')')
-					break;
-				if (IS_END_OF_FORMAT(*format))
-					return "Unmatched left paren in format "
-					       "string";
-				msg = skipitem(&format, p_va, flags);
-				if (msg)
-					return msg;
-			}
-			format++;
-			break;
-		}
-
-	case ')':
-		return "Unmatched right paren in format string";
-
-	default:
+        {
+            (void) va_arg(*p_va, PyObject **);
+            break;
+        }
+
+    case 'O': /* object */
+        {
+            if (*format == '!') {
+                format++;
+                (void) va_arg(*p_va, PyTypeObject*);
+                (void) va_arg(*p_va, PyObject **);
+            }
+            else if (*format == '&') {
+                typedef int (*converter)(PyObject *, void *);
+                (void) va_arg(*p_va, converter);
+                (void) va_arg(*p_va, void *);
+                format++;
+            }
+            else {
+                (void) va_arg(*p_va, PyObject **);
+            }
+            break;
+        }
+
+    case '(':           /* bypass tuple, not handled at all previously */
+        {
+            char *msg;
+            for (;;) {
+                if (*format==')')
+                    break;
+                if (IS_END_OF_FORMAT(*format))
+                    return "Unmatched left paren in format "
+                           "string";
+                msg = skipitem(&format, p_va, flags);
+                if (msg)
+                    return msg;
+            }
+            format++;
+            break;
+        }
+
+    case ')':
+        return "Unmatched right paren in format string";
+
+    default:
 err:
-		return "impossible<bad format char>";
-	
-	}
+        return "impossible<bad format char>";
+
+    }
 
-	*p_format = format;
-	return NULL;
+    *p_format = format;
+    return NULL;
 }
 
 
 int
 PyArg_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, ...)
 {
-	Py_ssize_t i, l;
-	PyObject **o;
-	va_list vargs;
+    Py_ssize_t i, l;
+    PyObject **o;
+    va_list vargs;
 
 #ifdef HAVE_STDARG_PROTOTYPES
-	va_start(vargs, max);
+    va_start(vargs, max);
 #else
-	va_start(vargs);
+    va_start(vargs);
 #endif
 
-	assert(min >= 0);
-	assert(min <= max);
-	if (!PyTuple_Check(args)) {
-		PyErr_SetString(PyExc_SystemError,
-		    "PyArg_UnpackTuple() argument list is not a tuple");
-		return 0;
-	}	
-	l = PyTuple_GET_SIZE(args);
-	if (l < min) {
-		if (name != NULL)
-			PyErr_Format(
-			    PyExc_TypeError,
-			    "%s expected %s%zd arguments, got %zd", 
-			    name, (min == max ? "" : "at least "), min, l);
-		else
-			PyErr_Format(
-			    PyExc_TypeError,
-			    "unpacked tuple should have %s%zd elements,"
-			    " but has %zd", 
-			    (min == max ? "" : "at least "), min, l);
-		va_end(vargs);
-		return 0;
-	}
-	if (l > max) {
-		if (name != NULL)
-			PyErr_Format(
-			    PyExc_TypeError,
-			    "%s expected %s%zd arguments, got %zd", 
-			    name, (min == max ? "" : "at most "), max, l);
-		else
-			PyErr_Format(
-			    PyExc_TypeError,
-			    "unpacked tuple should have %s%zd elements,"
-			    " but has %zd", 
-			    (min == max ? "" : "at most "), max, l);
-		va_end(vargs);
-		return 0;
-	}
-	for (i = 0; i < l; i++) {
-		o = va_arg(vargs, PyObject **);
-		*o = PyTuple_GET_ITEM(args, i);
-	}
-	va_end(vargs);
-	return 1;
+    assert(min >= 0);
+    assert(min <= max);
+    if (!PyTuple_Check(args)) {
+        PyErr_SetString(PyExc_SystemError,
+            "PyArg_UnpackTuple() argument list is not a tuple");
+        return 0;
+    }
+    l = PyTuple_GET_SIZE(args);
+    if (l < min) {
+        if (name != NULL)
+            PyErr_Format(
+                PyExc_TypeError,
+                "%s expected %s%zd arguments, got %zd",
+                name, (min == max ? "" : "at least "), min, l);
+        else
+            PyErr_Format(
+                PyExc_TypeError,
+                "unpacked tuple should have %s%zd elements,"
+                " but has %zd",
+                (min == max ? "" : "at least "), min, l);
+        va_end(vargs);
+        return 0;
+    }
+    if (l > max) {
+        if (name != NULL)
+            PyErr_Format(
+                PyExc_TypeError,
+                "%s expected %s%zd arguments, got %zd",
+                name, (min == max ? "" : "at most "), max, l);
+        else
+            PyErr_Format(
+                PyExc_TypeError,
+                "unpacked tuple should have %s%zd elements,"
+                " but has %zd",
+                (min == max ? "" : "at most "), max, l);
+        va_end(vargs);
+        return 0;
+    }
+    for (i = 0; i < l; i++) {
+        o = va_arg(vargs, PyObject **);
+        *o = PyTuple_GET_ITEM(args, i);
+    }
+    va_end(vargs);
+    return 1;
 }
 
 
 /* For type constructors that don't take keyword args
  *
- * Sets a TypeError and returns 0 if the kwds dict is 
+ * Sets a TypeError and returns 0 if the kwds dict is
  * not empty, returns 1 otherwise
  */
 int
 _PyArg_NoKeywords(const char *funcname, PyObject *kw)
 {
-	if (kw == NULL)
-		return 1;
-	if (!PyDict_CheckExact(kw)) {
-		PyErr_BadInternalCall();
-		return 0;
-	}
-	if (PyDict_Size(kw) == 0)
-		return 1;
-	
-	PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments", 
-			funcname);
-	return 0;
+    if (kw == NULL)
+        return 1;
+    if (!PyDict_CheckExact(kw)) {
+        PyErr_BadInternalCall();
+        return 0;
+    }
+    if (PyDict_Size(kw) == 0)
+        return 1;
+
+    PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",
+                    funcname);
+    return 0;
 }
 #ifdef __cplusplus
 };
diff --git a/Python/getcwd.c b/Python/getcwd.c
index 36fcd5c..44dc9e6 100644
--- a/Python/getcwd.c
+++ b/Python/getcwd.c
@@ -26,24 +26,24 @@ extern char *getwd(char *);
 char *
 getcwd(char *buf, int size)
 {
-	char localbuf[MAXPATHLEN+1];
-	char *ret;
+    char localbuf[MAXPATHLEN+1];
+    char *ret;
 
-	if (size <= 0) {
-		errno = EINVAL;
-		return NULL;
-	}
-	ret = getwd(localbuf);
-	if (ret != NULL && strlen(localbuf) >= (size_t)size) {
-		errno = ERANGE;
-		return NULL;
-	}
-	if (ret == NULL) {
-		errno = EACCES; /* Most likely error */
-		return NULL;
-	}
-	strncpy(buf, localbuf, size);
-	return buf;
+    if (size <= 0) {
+        errno = EINVAL;
+        return NULL;
+    }
+    ret = getwd(localbuf);
+    if (ret != NULL && strlen(localbuf) >= (size_t)size) {
+        errno = ERANGE;
+        return NULL;
+    }
+    if (ret == NULL) {
+        errno = EACCES; /* Most likely error */
+        return NULL;
+    }
+    strncpy(buf, localbuf, size);
+    return buf;
 }
 
 #else /* !HAVE_GETWD */
@@ -57,26 +57,26 @@ getcwd(char *buf, int size)
 char *
 getcwd(char *buf, int size)
 {
-	FILE *fp;
-	char *p;
-	if (size <= 0) {
-		errno = EINVAL;
-		return NULL;
-	}
-	if ((fp = popen(PWD_CMD, "r")) == NULL)
-		return NULL;
-	if (fgets(buf, size, fp) == NULL || pclose(fp) != 0) {
-		errno = EACCES; /* Most likely error */
-		return NULL;
-	}
-	for (p = buf; *p != '\n'; p++) {
-		if (*p == '\0') {
-			errno = ERANGE;
-			return NULL;
-		}
-	}
-	*p = '\0';
-	return buf;
+    FILE *fp;
+    char *p;
+    if (size <= 0) {
+        errno = EINVAL;
+        return NULL;
+    }
+    if ((fp = popen(PWD_CMD, "r")) == NULL)
+        return NULL;
+    if (fgets(buf, size, fp) == NULL || pclose(fp) != 0) {
+        errno = EACCES; /* Most likely error */
+        return NULL;
+    }
+    for (p = buf; *p != '\n'; p++) {
+        if (*p == '\0') {
+            errno = ERANGE;
+            return NULL;
+        }
+    }
+    *p = '\0';
+    return buf;
 }
 
 #endif /* !HAVE_GETWD */
diff --git a/Python/getopt.c b/Python/getopt.c
index 247600b..093c3da 100644
--- a/Python/getopt.c
+++ b/Python/getopt.c
@@ -7,8 +7,8 @@
  *
  *                    All Rights Reserved
  *
- * Permission to use, copy, modify, and distribute this software and its 
- * documentation for any purpose and without fee is hereby granted, 
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose and without fee is hereby granted,
  * provided that the above copyright notice, this permission notice and
  * the following disclaimer notice appear unmodified in all copies.
  *
@@ -40,84 +40,84 @@ char *_PyOS_optarg = NULL;     /* optional argument       */
 
 int _PyOS_GetOpt(int argc, char **argv, char *optstring)
 {
-	static char *opt_ptr = "";
-	char *ptr;
-	int option;
+    static char *opt_ptr = "";
+    char *ptr;
+    int option;
 
-	if (*opt_ptr == '\0') {
+    if (*opt_ptr == '\0') {
 
-		if (_PyOS_optind >= argc)
-			return -1;
+        if (_PyOS_optind >= argc)
+            return -1;
 #ifdef MS_WINDOWS
-		else if (strcmp(argv[_PyOS_optind], "/?") == 0) {
-			++_PyOS_optind;
-			return 'h';
-		}
+        else if (strcmp(argv[_PyOS_optind], "/?") == 0) {
+            ++_PyOS_optind;
+            return 'h';
+        }
 #endif
 
-		else if (argv[_PyOS_optind][0] != '-' ||
-		         argv[_PyOS_optind][1] == '\0' /* lone dash */ )
-			return -1;
-
-		else if (strcmp(argv[_PyOS_optind], "--") == 0) {
-			++_PyOS_optind;
-			return -1;
-		}
-
-		else if (strcmp(argv[_PyOS_optind], "--help") == 0) {
-			++_PyOS_optind;
-			return 'h';
-		}
-
-		else if (strcmp(argv[_PyOS_optind], "--version") == 0) {
-			++_PyOS_optind;
-			return 'V';
-		}
-
-
-		opt_ptr = &argv[_PyOS_optind++][1]; 
-	}
-
-	if ( (option = *opt_ptr++) == '\0')
-		return -1;
-
-	if (option == 'J') {
-		fprintf(stderr, "-J is reserved for Jython\n");
-		return '_';
-	}
-
-	if (option == 'X') {
-		fprintf(stderr,
-		  "-X is reserved for implementation-specific arguments\n");
-		return '_';
-	}
-
-	if ((ptr = strchr(optstring, option)) == NULL) {
-		if (_PyOS_opterr)
-			fprintf(stderr, "Unknown option: -%c\n", option);
-
-		return '_';
-	}
-
-	if (*(ptr + 1) == ':') {
-		if (*opt_ptr != '\0') {
-			_PyOS_optarg  = opt_ptr;
-			opt_ptr = "";
-		}
-
-		else {
-			if (_PyOS_optind >= argc) {
-				if (_PyOS_opterr)
-					fprintf(stderr,
-			    "Argument expected for the -%c option\n", option);
-				return '_';
-			}
-
-			_PyOS_optarg = argv[_PyOS_optind++];
-		}
-	}
-
-	return option;
+        else if (argv[_PyOS_optind][0] != '-' ||
+                 argv[_PyOS_optind][1] == '\0' /* lone dash */ )
+            return -1;
+
+        else if (strcmp(argv[_PyOS_optind], "--") == 0) {
+            ++_PyOS_optind;
+            return -1;
+        }
+
+        else if (strcmp(argv[_PyOS_optind], "--help") == 0) {
+            ++_PyOS_optind;
+            return 'h';
+        }
+
+        else if (strcmp(argv[_PyOS_optind], "--version") == 0) {
+            ++_PyOS_optind;
+            return 'V';
+        }
+
+
+        opt_ptr = &argv[_PyOS_optind++][1];
+    }
+
+    if ( (option = *opt_ptr++) == '\0')
+        return -1;
+
+    if (option == 'J') {
+        fprintf(stderr, "-J is reserved for Jython\n");
+        return '_';
+    }
+
+    if (option == 'X') {
+        fprintf(stderr,
+          "-X is reserved for implementation-specific arguments\n");
+        return '_';
+    }
+
+    if ((ptr = strchr(optstring, option)) == NULL) {
+        if (_PyOS_opterr)
+            fprintf(stderr, "Unknown option: -%c\n", option);
+
+        return '_';
+    }
+
+    if (*(ptr + 1) == ':') {
+        if (*opt_ptr != '\0') {
+            _PyOS_optarg  = opt_ptr;
+            opt_ptr = "";
+        }
+
+        else {
+            if (_PyOS_optind >= argc) {
+                if (_PyOS_opterr)
+                    fprintf(stderr,
+                "Argument expected for the -%c option\n", option);
+                return '_';
+            }
+
+            _PyOS_optarg = argv[_PyOS_optind++];
+        }
+    }
+
+    return option;
 }
 
 #ifdef __cplusplus
diff --git a/Python/import.c b/Python/import.c
index a5e23e8..7abe679 100644
--- a/Python/import.c
+++ b/Python/import.c
@@ -67,13 +67,13 @@ typedef unsigned short mode_t;
        Python 2.5b3: 62101 (fix wrong code: for x, in ...)
        Python 2.5b3: 62111 (fix wrong code: x += yield)
        Python 2.5c1: 62121 (fix wrong lnotab with for loops and
-       			    storing constants that should have been removed)
+                            storing constants that should have been removed)
        Python 2.5c2: 62131 (fix wrong code: for x, in ... in listcomp/genexp)
        Python 2.6a0: 62151 (peephole optimizations and STORE_MAP opcode)
        Python 2.6a1: 62161 (WITH_CLEANUP optimization)
        Python 2.7a0: 62171 (optimize list comprehensions/change LIST_APPEND)
        Python 2.7a0: 62181 (optimize conditional branches:
-			    introduce POP_JUMP_IF_FALSE and POP_JUMP_IF_TRUE)
+                introduce POP_JUMP_IF_FALSE and POP_JUMP_IF_TRUE)
        Python 2.7a0  62191 (introduce SETUP_WITH)
        Python 2.7a0  62201 (introduce BUILD_SET)
        Python 2.7a0  62211 (introduce MAP_ADD and SET_ADD)
@@ -99,18 +99,18 @@ struct filedescr * _PyImport_Filetab = NULL;
 
 #ifdef RISCOS
 static const struct filedescr _PyImport_StandardFiletab[] = {
-	{"/py", "U", PY_SOURCE},
-	{"/pyc", "rb", PY_COMPILED},
-	{0, 0}
+    {"/py", "U", PY_SOURCE},
+    {"/pyc", "rb", PY_COMPILED},
+    {0, 0}
 };
 #else
 static const struct filedescr _PyImport_StandardFiletab[] = {
-	{".py", "U", PY_SOURCE},
+    {".py", "U", PY_SOURCE},
 #ifdef MS_WINDOWS
-	{".pyw", "U", PY_SOURCE},
+    {".pyw", "U", PY_SOURCE},
 #endif
-	{".pyc", "rb", PY_COMPILED},
-	{0, 0}
+    {".pyc", "rb", PY_COMPILED},
+    {0, 0}
 };
 #endif
 
@@ -120,131 +120,131 @@ static const struct filedescr _PyImport_StandardFiletab[] = {
 void
 _PyImport_Init(void)
 {
-	const struct filedescr *scan;
-	struct filedescr *filetab;
-	int countD = 0;
-	int countS = 0;
+    const struct filedescr *scan;
+    struct filedescr *filetab;
+    int countD = 0;
+    int countS = 0;
 
-	/* prepare _PyImport_Filetab: copy entries from
-	   _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
-	 */
+    /* prepare _PyImport_Filetab: copy entries from
+       _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
+     */
 #ifdef HAVE_DYNAMIC_LOADING
-	for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)
-		++countD;
+    for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)
+        ++countD;
 #endif
-	for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
-		++countS;
-	filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
-	if (filetab == NULL)
-		Py_FatalError("Can't initialize import file table.");
+    for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
+        ++countS;
+    filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
+    if (filetab == NULL)
+        Py_FatalError("Can't initialize import file table.");
 #ifdef HAVE_DYNAMIC_LOADING
-	memcpy(filetab, _PyImport_DynLoadFiletab,
-	       countD * sizeof(struct filedescr));
+    memcpy(filetab, _PyImport_DynLoadFiletab,
+           countD * sizeof(struct filedescr));
 #endif
-	memcpy(filetab + countD, _PyImport_StandardFiletab,
-	       countS * sizeof(struct filedescr));
-	filetab[countD + countS].suffix = NULL;
+    memcpy(filetab + countD, _PyImport_StandardFiletab,
+           countS * sizeof(struct filedescr));
+    filetab[countD + countS].suffix = NULL;
 
-	_PyImport_Filetab = filetab;
+    _PyImport_Filetab = filetab;
 
-	if (Py_OptimizeFlag) {
-		/* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
-		for (; filetab->suffix != NULL; filetab++) {
+    if (Py_OptimizeFlag) {
+        /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
+        for (; filetab->suffix != NULL; filetab++) {
 #ifndef RISCOS
-			if (strcmp(filetab->suffix, ".pyc") == 0)
-				filetab->suffix = ".pyo";
+            if (strcmp(filetab->suffix, ".pyc") == 0)
+                filetab->suffix = ".pyo";
 #else
-			if (strcmp(filetab->suffix, "/pyc") == 0)
-				filetab->suffix = "/pyo";
+            if (strcmp(filetab->suffix, "/pyc") == 0)
+                filetab->suffix = "/pyo";
 #endif
-		}
-	}
+        }
+    }
 
-	if (Py_UnicodeFlag) {
-		/* Fix the pyc_magic so that byte compiled code created
-		   using the all-Unicode method doesn't interfere with
-		   code created in normal operation mode. */
-		pyc_magic = MAGIC + 1;
-	}
+    if (Py_UnicodeFlag) {
+        /* Fix the pyc_magic so that byte compiled code created
+           using the all-Unicode method doesn't interfere with
+           code created in normal operation mode. */
+        pyc_magic = MAGIC + 1;
+    }
 }
 
 void
 _PyImportHooks_Init(void)
 {
-	PyObject *v, *path_hooks = NULL, *zimpimport;
-	int err = 0;
-
-	/* adding sys.path_hooks and sys.path_importer_cache, setting up
-	   zipimport */
-	if (PyType_Ready(&PyNullImporter_Type) < 0)
-		goto error;
-
-	if (Py_VerboseFlag)
-		PySys_WriteStderr("# installing zipimport hook\n");
-
-	v = PyList_New(0);
-	if (v == NULL)
-		goto error;
-	err = PySys_SetObject("meta_path", v);
-	Py_DECREF(v);
-	if (err)
-		goto error;
-	v = PyDict_New();
-	if (v == NULL)
-		goto error;
-	err = PySys_SetObject("path_importer_cache", v);
-	Py_DECREF(v);
-	if (err)
-		goto error;
-	path_hooks = PyList_New(0);
-	if (path_hooks == NULL)
-		goto error;
-	err = PySys_SetObject("path_hooks", path_hooks);
-	if (err) {
+    PyObject *v, *path_hooks = NULL, *zimpimport;
+    int err = 0;
+
+    /* adding sys.path_hooks and sys.path_importer_cache, setting up
+       zipimport */
+    if (PyType_Ready(&PyNullImporter_Type) < 0)
+        goto error;
+
+    if (Py_VerboseFlag)
+        PySys_WriteStderr("# installing zipimport hook\n");
+
+    v = PyList_New(0);
+    if (v == NULL)
+        goto error;
+    err = PySys_SetObject("meta_path", v);
+    Py_DECREF(v);
+    if (err)
+        goto error;
+    v = PyDict_New();
+    if (v == NULL)
+        goto error;
+    err = PySys_SetObject("path_importer_cache", v);
+    Py_DECREF(v);
+    if (err)
+        goto error;
+    path_hooks = PyList_New(0);
+    if (path_hooks == NULL)
+        goto error;
+    err = PySys_SetObject("path_hooks", path_hooks);
+    if (err) {
   error:
-		PyErr_Print();
-		Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
-			      "path_importer_cache, or NullImporter failed"
-			      );
-	}
-
-	zimpimport = PyImport_ImportModule("zipimport");
-	if (zimpimport == NULL) {
-		PyErr_Clear(); /* No zip import module -- okay */
-		if (Py_VerboseFlag)
-			PySys_WriteStderr("# can't import zipimport\n");
-	}
-	else {
-		PyObject *zipimporter = PyObject_GetAttrString(zimpimport,
-							       "zipimporter");
-		Py_DECREF(zimpimport);
-		if (zipimporter == NULL) {
-			PyErr_Clear(); /* No zipimporter object -- okay */
-			if (Py_VerboseFlag)
-				PySys_WriteStderr(
-				    "# can't import zipimport.zipimporter\n");
-		}
-		else {
-			/* sys.path_hooks.append(zipimporter) */
-			err = PyList_Append(path_hooks, zipimporter);
-			Py_DECREF(zipimporter);
-			if (err)
-				goto error;
-			if (Py_VerboseFlag)
-				PySys_WriteStderr(
-					"# installed zipimport hook\n");
-		}
-	}
-	Py_DECREF(path_hooks);
+        PyErr_Print();
+        Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
+                      "path_importer_cache, or NullImporter failed"
+                      );
+    }
+
+    zimpimport = PyImport_ImportModule("zipimport");
+    if (zimpimport == NULL) {
+        PyErr_Clear(); /* No zip import module -- okay */
+        if (Py_VerboseFlag)
+            PySys_WriteStderr("# can't import zipimport\n");
+    }
+    else {
+        PyObject *zipimporter = PyObject_GetAttrString(zimpimport,
+                                                       "zipimporter");
+        Py_DECREF(zimpimport);
+        if (zipimporter == NULL) {
+            PyErr_Clear(); /* No zipimporter object -- okay */
+            if (Py_VerboseFlag)
+                PySys_WriteStderr(
+                    "# can't import zipimport.zipimporter\n");
+        }
+        else {
+            /* sys.path_hooks.append(zipimporter) */
+            err = PyList_Append(path_hooks, zipimporter);
+            Py_DECREF(zipimporter);
+            if (err)
+                goto error;
+            if (Py_VerboseFlag)
+                PySys_WriteStderr(
+                    "# installed zipimport hook\n");
+        }
+    }
+    Py_DECREF(path_hooks);
 }
 
 void
 _PyImport_Fini(void)
 {
-	Py_XDECREF(extensions);
-	extensions = NULL;
-	PyMem_DEL(_PyImport_Filetab);
-	_PyImport_Filetab = NULL;
+    Py_XDECREF(extensions);
+    extensions = NULL;
+    PyMem_DEL(_PyImport_Filetab);
+    _PyImport_Filetab = NULL;
 }
 
 
@@ -263,42 +263,42 @@ static int import_lock_level = 0;
 void
 _PyImport_AcquireLock(void)
 {
-	long me = PyThread_get_thread_ident();
-	if (me == -1)
-		return; /* Too bad */
-	if (import_lock == NULL) {
-		import_lock = PyThread_allocate_lock();
-		if (import_lock == NULL)
-			return;  /* Nothing much we can do. */
-	}
-	if (import_lock_thread == me) {
-		import_lock_level++;
-		return;
-	}
-	if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
-	{
-		PyThreadState *tstate = PyEval_SaveThread();
-		PyThread_acquire_lock(import_lock, 1);
-		PyEval_RestoreThread(tstate);
-	}
-	import_lock_thread = me;
-	import_lock_level = 1;
+    long me = PyThread_get_thread_ident();
+    if (me == -1)
+        return; /* Too bad */
+    if (import_lock == NULL) {
+        import_lock = PyThread_allocate_lock();
+        if (import_lock == NULL)
+            return;  /* Nothing much we can do. */
+    }
+    if (import_lock_thread == me) {
+        import_lock_level++;
+        return;
+    }
+    if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
+    {
+        PyThreadState *tstate = PyEval_SaveThread();
+        PyThread_acquire_lock(import_lock, 1);
+        PyEval_RestoreThread(tstate);
+    }
+    import_lock_thread = me;
+    import_lock_level = 1;
 }
 
 int
 _PyImport_ReleaseLock(void)
 {
-	long me = PyThread_get_thread_ident();
-	if (me == -1 || import_lock == NULL)
-		return 0; /* Too bad */
-	if (import_lock_thread != me)
-		return -1;
-	import_lock_level--;
-	if (import_lock_level == 0) {
-		import_lock_thread = -1;
-		PyThread_release_lock(import_lock);
-	}
-	return 1;
+    long me = PyThread_get_thread_ident();
+    if (me == -1 || import_lock == NULL)
+        return 0; /* Too bad */
+    if (import_lock_thread != me)
+        return -1;
+    import_lock_level--;
+    if (import_lock_level == 0) {
+        import_lock_thread = -1;
+        PyThread_release_lock(import_lock);
+    }
+    return 1;
 }
 
 /* This function is called from PyOS_AfterFork to ensure that newly
@@ -309,10 +309,10 @@ _PyImport_ReleaseLock(void)
 void
 _PyImport_ReInitLock(void)
 {
- 	if (import_lock != NULL)
- 		import_lock = PyThread_allocate_lock();
- 	import_lock_thread = -1;
- 	import_lock_level = 0;
+    if (import_lock != NULL)
+        import_lock = PyThread_allocate_lock();
+    import_lock_thread = -1;
+    import_lock_level = 0;
 }
 
 #endif
@@ -321,9 +321,9 @@ static PyObject *
 imp_lock_held(PyObject *self, PyObject *noargs)
 {
 #ifdef WITH_THREAD
-	return PyBool_FromLong(import_lock_thread != -1);
+    return PyBool_FromLong(import_lock_thread != -1);
 #else
-	return PyBool_FromLong(0);
+    return PyBool_FromLong(0);
 #endif
 }
 
@@ -331,32 +331,32 @@ static PyObject *
 imp_acquire_lock(PyObject *self, PyObject *noargs)
 {
 #ifdef WITH_THREAD
-	_PyImport_AcquireLock();
+    _PyImport_AcquireLock();
 #endif
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 imp_release_lock(PyObject *self, PyObject *noargs)
 {
 #ifdef WITH_THREAD
-	if (_PyImport_ReleaseLock() < 0) {
-		PyErr_SetString(PyExc_RuntimeError,
-				"not holding the import lock");
-		return NULL;
-	}
+    if (_PyImport_ReleaseLock() < 0) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "not holding the import lock");
+        return NULL;
+    }
 #endif
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static void
 imp_modules_reloading_clear(void)
 {
-	PyInterpreterState *interp = PyThreadState_Get()->interp;
-	if (interp->modules_reloading != NULL)
-		PyDict_Clear(interp->modules_reloading);
+    PyInterpreterState *interp = PyThreadState_Get()->interp;
+    if (interp->modules_reloading != NULL)
+        PyDict_Clear(interp->modules_reloading);
 }
 
 /* Helper for sys */
@@ -364,29 +364,29 @@ imp_modules_reloading_clear(void)
 PyObject *
 PyImport_GetModuleDict(void)
 {
-	PyInterpreterState *interp = PyThreadState_GET()->interp;
-	if (interp->modules == NULL)
-		Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
-	return interp->modules;
+    PyInterpreterState *interp = PyThreadState_GET()->interp;
+    if (interp->modules == NULL)
+        Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
+    return interp->modules;
 }
 
 
 /* List of names to clear in sys */
 static char* sys_deletes[] = {
-	"path", "argv", "ps1", "ps2", "exitfunc",
-	"exc_type", "exc_value", "exc_traceback",
-	"last_type", "last_value", "last_traceback",
-	"path_hooks", "path_importer_cache", "meta_path",
-	/* misc stuff */
-	"flags", "float_info",
-	NULL
+    "path", "argv", "ps1", "ps2", "exitfunc",
+    "exc_type", "exc_value", "exc_traceback",
+    "last_type", "last_value", "last_traceback",
+    "path_hooks", "path_importer_cache", "meta_path",
+    /* misc stuff */
+    "flags", "float_info",
+    NULL
 };
 
 static char* sys_files[] = {
-	"stdin", "__stdin__",
-	"stdout", "__stdout__",
-	"stderr", "__stderr__",
-	NULL
+    "stdin", "__stdin__",
+    "stdout", "__stdout__",
+    "stderr", "__stderr__",
+    NULL
 };
 
 
@@ -395,132 +395,132 @@ static char* sys_files[] = {
 void
 PyImport_Cleanup(void)
 {
-	Py_ssize_t pos, ndone;
-	char *name;
-	PyObject *key, *value, *dict;
-	PyInterpreterState *interp = PyThreadState_GET()->interp;
-	PyObject *modules = interp->modules;
-
-	if (modules == NULL)
-		return; /* Already done */
-
-	/* Delete some special variables first.  These are common
-	   places where user values hide and people complain when their
-	   destructors fail.  Since the modules containing them are
-	   deleted *last* of all, they would come too late in the normal
-	   destruction order.  Sigh. */
-
-	value = PyDict_GetItemString(modules, "__builtin__");
-	if (value != NULL && PyModule_Check(value)) {
-		dict = PyModule_GetDict(value);
-		if (Py_VerboseFlag)
-			PySys_WriteStderr("# clear __builtin__._\n");
-		PyDict_SetItemString(dict, "_", Py_None);
-	}
-	value = PyDict_GetItemString(modules, "sys");
-	if (value != NULL && PyModule_Check(value)) {
-		char **p;
-		PyObject *v;
-		dict = PyModule_GetDict(value);
-		for (p = sys_deletes; *p != NULL; p++) {
-			if (Py_VerboseFlag)
-				PySys_WriteStderr("# clear sys.%s\n", *p);
-			PyDict_SetItemString(dict, *p, Py_None);
-		}
-		for (p = sys_files; *p != NULL; p+=2) {
-			if (Py_VerboseFlag)
-				PySys_WriteStderr("# restore sys.%s\n", *p);
-			v = PyDict_GetItemString(dict, *(p+1));
-			if (v == NULL)
-				v = Py_None;
-			PyDict_SetItemString(dict, *p, v);
-		}
-	}
-
-	/* First, delete __main__ */
-	value = PyDict_GetItemString(modules, "__main__");
-	if (value != NULL && PyModule_Check(value)) {
-		if (Py_VerboseFlag)
-			PySys_WriteStderr("# cleanup __main__\n");
-		_PyModule_Clear(value);
-		PyDict_SetItemString(modules, "__main__", Py_None);
-	}
-
-	/* The special treatment of __builtin__ here is because even
-	   when it's not referenced as a module, its dictionary is
-	   referenced by almost every module's __builtins__.  Since
-	   deleting a module clears its dictionary (even if there are
-	   references left to it), we need to delete the __builtin__
-	   module last.  Likewise, we don't delete sys until the very
-	   end because it is implicitly referenced (e.g. by print).
-
-	   Also note that we 'delete' modules by replacing their entry
-	   in the modules dict with None, rather than really deleting
-	   them; this avoids a rehash of the modules dictionary and
-	   also marks them as "non existent" so they won't be
-	   re-imported. */
-
-	/* Next, repeatedly delete modules with a reference count of
-	   one (skipping __builtin__ and sys) and delete them */
-	do {
-		ndone = 0;
-		pos = 0;
-		while (PyDict_Next(modules, &pos, &key, &value)) {
-			if (value->ob_refcnt != 1)
-				continue;
-			if (PyString_Check(key) && PyModule_Check(value)) {
-				name = PyString_AS_STRING(key);
-				if (strcmp(name, "__builtin__") == 0)
-					continue;
-				if (strcmp(name, "sys") == 0)
-					continue;
-				if (Py_VerboseFlag)
-					PySys_WriteStderr(
-						"# cleanup[1] %s\n", name);
-				_PyModule_Clear(value);
-				PyDict_SetItem(modules, key, Py_None);
-				ndone++;
-			}
-		}
-	} while (ndone > 0);
-
-	/* Next, delete all modules (still skipping __builtin__ and sys) */
-	pos = 0;
-	while (PyDict_Next(modules, &pos, &key, &value)) {
-		if (PyString_Check(key) && PyModule_Check(value)) {
-			name = PyString_AS_STRING(key);
-			if (strcmp(name, "__builtin__") == 0)
-				continue;
-			if (strcmp(name, "sys") == 0)
-				continue;
-			if (Py_VerboseFlag)
-				PySys_WriteStderr("# cleanup[2] %s\n", name);
-			_PyModule_Clear(value);
-			PyDict_SetItem(modules, key, Py_None);
-		}
-	}
-
-	/* Next, delete sys and __builtin__ (in that order) */
-	value = PyDict_GetItemString(modules, "sys");
-	if (value != NULL && PyModule_Check(value)) {
-		if (Py_VerboseFlag)
-			PySys_WriteStderr("# cleanup sys\n");
-		_PyModule_Clear(value);
-		PyDict_SetItemString(modules, "sys", Py_None);
-	}
-	value = PyDict_GetItemString(modules, "__builtin__");
-	if (value != NULL && PyModule_Check(value)) {
-		if (Py_VerboseFlag)
-			PySys_WriteStderr("# cleanup __builtin__\n");
-		_PyModule_Clear(value);
-		PyDict_SetItemString(modules, "__builtin__", Py_None);
-	}
-
-	/* Finally, clear and delete the modules directory */
-	PyDict_Clear(modules);
-	interp->modules = NULL;
-	Py_DECREF(modules);
-	Py_CLEAR(interp->modules_reloading);
+    Py_ssize_t pos, ndone;
+    char *name;
+    PyObject *key, *value, *dict;
+    PyInterpreterState *interp = PyThreadState_GET()->interp;
+    PyObject *modules = interp->modules;
+
+    if (modules == NULL)
+        return; /* Already done */
+
+    /* Delete some special variables first.  These are common
+       places where user values hide and people complain when their
+       destructors fail.  Since the modules containing them are
+       deleted *last* of all, they would come too late in the normal
+       destruction order.  Sigh. */
+
+    value = PyDict_GetItemString(modules, "__builtin__");
+    if (value != NULL && PyModule_Check(value)) {
+        dict = PyModule_GetDict(value);
+        if (Py_VerboseFlag)
+            PySys_WriteStderr("# clear __builtin__._\n");
+        PyDict_SetItemString(dict, "_", Py_None);
+    }
+    value = PyDict_GetItemString(modules, "sys");
+    if (value != NULL && PyModule_Check(value)) {
+        char **p;
+        PyObject *v;
+        dict = PyModule_GetDict(value);
+        for (p = sys_deletes; *p != NULL; p++) {
+            if (Py_VerboseFlag)
+                PySys_WriteStderr("# clear sys.%s\n", *p);
+            PyDict_SetItemString(dict, *p, Py_None);
+        }
+        for (p = sys_files; *p != NULL; p+=2) {
+            if (Py_VerboseFlag)
+                PySys_WriteStderr("# restore sys.%s\n", *p);
+            v = PyDict_GetItemString(dict, *(p+1));
+            if (v == NULL)
+                v = Py_None;
+            PyDict_SetItemString(dict, *p, v);
+        }
+    }
+
+    /* First, delete __main__ */
+    value = PyDict_GetItemString(modules, "__main__");
+    if (value != NULL && PyModule_Check(value)) {
+        if (Py_VerboseFlag)
+            PySys_WriteStderr("# cleanup __main__\n");
+        _PyModule_Clear(value);
+        PyDict_SetItemString(modules, "__main__", Py_None);
+    }
+
+    /* The special treatment of __builtin__ here is because even
+       when it's not referenced as a module, its dictionary is
+       referenced by almost every module's __builtins__.  Since
+       deleting a module clears its dictionary (even if there are
+       references left to it), we need to delete the __builtin__
+       module last.  Likewise, we don't delete sys until the very
+       end because it is implicitly referenced (e.g. by print).
+
+       Also note that we 'delete' modules by replacing their entry
+       in the modules dict with None, rather than really deleting
+       them; this avoids a rehash of the modules dictionary and
+       also marks them as "non existent" so they won't be
+       re-imported. */
+
+    /* Next, repeatedly delete modules with a reference count of
+       one (skipping __builtin__ and sys) and delete them */
+    do {
+        ndone = 0;
+        pos = 0;
+        while (PyDict_Next(modules, &pos, &key, &value)) {
+            if (value->ob_refcnt != 1)
+                continue;
+            if (PyString_Check(key) && PyModule_Check(value)) {
+                name = PyString_AS_STRING(key);
+                if (strcmp(name, "__builtin__") == 0)
+                    continue;
+                if (strcmp(name, "sys") == 0)
+                    continue;
+                if (Py_VerboseFlag)
+                    PySys_WriteStderr(
+                        "# cleanup[1] %s\n", name);
+                _PyModule_Clear(value);
+                PyDict_SetItem(modules, key, Py_None);
+                ndone++;
+            }
+        }
+    } while (ndone > 0);
+
+    /* Next, delete all modules (still skipping __builtin__ and sys) */
+    pos = 0;
+    while (PyDict_Next(modules, &pos, &key, &value)) {
+        if (PyString_Check(key) && PyModule_Check(value)) {
+            name = PyString_AS_STRING(key);
+            if (strcmp(name, "__builtin__") == 0)
+                continue;
+            if (strcmp(name, "sys") == 0)
+                continue;
+            if (Py_VerboseFlag)
+                PySys_WriteStderr("# cleanup[2] %s\n", name);
+            _PyModule_Clear(value);
+            PyDict_SetItem(modules, key, Py_None);
+        }
+    }
+
+    /* Next, delete sys and __builtin__ (in that order) */
+    value = PyDict_GetItemString(modules, "sys");
+    if (value != NULL && PyModule_Check(value)) {
+        if (Py_VerboseFlag)
+            PySys_WriteStderr("# cleanup sys\n");
+        _PyModule_Clear(value);
+        PyDict_SetItemString(modules, "sys", Py_None);
+    }
+    value = PyDict_GetItemString(modules, "__builtin__");
+    if (value != NULL && PyModule_Check(value)) {
+        if (Py_VerboseFlag)
+            PySys_WriteStderr("# cleanup __builtin__\n");
+        _PyModule_Clear(value);
+        PyDict_SetItemString(modules, "__builtin__", Py_None);
+    }
+
+    /* Finally, clear and delete the modules directory */
+    PyDict_Clear(modules);
+    interp->modules = NULL;
+    Py_DECREF(modules);
+    Py_CLEAR(interp->modules_reloading);
 }
 
 
@@ -529,7 +529,7 @@ PyImport_Cleanup(void)
 long
 PyImport_GetMagicNumber(void)
 {
-	return pyc_magic;
+    return pyc_magic;
 }
 
 
@@ -546,51 +546,51 @@ PyImport_GetMagicNumber(void)
 PyObject *
 _PyImport_FixupExtension(char *name, char *filename)
 {
-	PyObject *modules, *mod, *dict, *copy;
-	if (extensions == NULL) {
-		extensions = PyDict_New();
-		if (extensions == NULL)
-			return NULL;
-	}
-	modules = PyImport_GetModuleDict();
-	mod = PyDict_GetItemString(modules, name);
-	if (mod == NULL || !PyModule_Check(mod)) {
-		PyErr_Format(PyExc_SystemError,
-		  "_PyImport_FixupExtension: module %.200s not loaded", name);
-		return NULL;
-	}
-	dict = PyModule_GetDict(mod);
-	if (dict == NULL)
-		return NULL;
-	copy = PyDict_Copy(dict);
-	if (copy == NULL)
-		return NULL;
-	PyDict_SetItemString(extensions, filename, copy);
-	Py_DECREF(copy);
-	return copy;
+    PyObject *modules, *mod, *dict, *copy;
+    if (extensions == NULL) {
+        extensions = PyDict_New();
+        if (extensions == NULL)
+            return NULL;
+    }
+    modules = PyImport_GetModuleDict();
+    mod = PyDict_GetItemString(modules, name);
+    if (mod == NULL || !PyModule_Check(mod)) {
+        PyErr_Format(PyExc_SystemError,
+          "_PyImport_FixupExtension: module %.200s not loaded", name);
+        return NULL;
+    }
+    dict = PyModule_GetDict(mod);
+    if (dict == NULL)
+        return NULL;
+    copy = PyDict_Copy(dict);
+    if (copy == NULL)
+        return NULL;
+    PyDict_SetItemString(extensions, filename, copy);
+    Py_DECREF(copy);
+    return copy;
 }
 
 PyObject *
 _PyImport_FindExtension(char *name, char *filename)
 {
-	PyObject *dict, *mod, *mdict;
-	if (extensions == NULL)
-		return NULL;
-	dict = PyDict_GetItemString(extensions, filename);
-	if (dict == NULL)
-		return NULL;
-	mod = PyImport_AddModule(name);
-	if (mod == NULL)
-		return NULL;
-	mdict = PyModule_GetDict(mod);
-	if (mdict == NULL)
-		return NULL;
-	if (PyDict_Update(mdict, dict))
-		return NULL;
-	if (Py_VerboseFlag)
-		PySys_WriteStderr("import %s # previously loaded (%s)\n",
-			name, filename);
-	return mod;
+    PyObject *dict, *mod, *mdict;
+    if (extensions == NULL)
+        return NULL;
+    dict = PyDict_GetItemString(extensions, filename);
+    if (dict == NULL)
+        return NULL;
+    mod = PyImport_AddModule(name);
+    if (mod == NULL)
+        return NULL;
+    mdict = PyModule_GetDict(mod);
+    if (mdict == NULL)
+        return NULL;
+    if (PyDict_Update(mdict, dict))
+        return NULL;
+    if (Py_VerboseFlag)
+        PySys_WriteStderr("import %s # previously loaded (%s)\n",
+            name, filename);
+    return mod;
 }
 
 
@@ -603,34 +603,34 @@ _PyImport_FindExtension(char *name, char *filename)
 PyObject *
 PyImport_AddModule(const char *name)
 {
-	PyObject *modules = PyImport_GetModuleDict();
-	PyObject *m;
+    PyObject *modules = PyImport_GetModuleDict();
+    PyObject *m;
 
-	if ((m = PyDict_GetItemString(modules, name)) != NULL &&
-	    PyModule_Check(m))
-		return m;
-	m = PyModule_New(name);
-	if (m == NULL)
-		return NULL;
-	if (PyDict_SetItemString(modules, name, m) != 0) {
-		Py_DECREF(m);
-		return NULL;
-	}
-	Py_DECREF(m); /* Yes, it still exists, in modules! */
+    if ((m = PyDict_GetItemString(modules, name)) != NULL &&
+        PyModule_Check(m))
+        return m;
+    m = PyModule_New(name);
+    if (m == NULL)
+        return NULL;
+    if (PyDict_SetItemString(modules, name, m) != 0) {
+        Py_DECREF(m);
+        return NULL;
+    }
+    Py_DECREF(m); /* Yes, it still exists, in modules! */
 
-	return m;
+    return m;
 }
 
 /* Remove name from sys.modules, if it's there. */
 static void
 remove_module(const char *name)
 {
-	PyObject *modules = PyImport_GetModuleDict();
-	if (PyDict_GetItemString(modules, name) == NULL)
-		return;
-	if (PyDict_DelItemString(modules, name) < 0)
-		Py_FatalError("import:  deleting existing key in"
-			      "sys.modules failed");
+    PyObject *modules = PyImport_GetModuleDict();
+    if (PyDict_GetItemString(modules, name) == NULL)
+        return;
+    if (PyDict_DelItemString(modules, name) < 0)
+        Py_FatalError("import:  deleting existing key in"
+                      "sys.modules failed");
 }
 
 /* Execute a code object in a module and return the module object
@@ -643,60 +643,60 @@ remove_module(const char *name)
 PyObject *
 PyImport_ExecCodeModule(char *name, PyObject *co)
 {
-	return PyImport_ExecCodeModuleEx(name, co, (char *)NULL);
+    return PyImport_ExecCodeModuleEx(name, co, (char *)NULL);
 }
 
 PyObject *
 PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
 {
-	PyObject *modules = PyImport_GetModuleDict();
-	PyObject *m, *d, *v;
-
-	m = PyImport_AddModule(name);
-	if (m == NULL)
-		return NULL;
-	/* If the module is being reloaded, we get the old module back
-	   and re-use its dict to exec the new code. */
-	d = PyModule_GetDict(m);
-	if (PyDict_GetItemString(d, "__builtins__") == NULL) {
-		if (PyDict_SetItemString(d, "__builtins__",
-					 PyEval_GetBuiltins()) != 0)
-			goto error;
-	}
-	/* Remember the filename as the __file__ attribute */
-	v = NULL;
-	if (pathname != NULL) {
-		v = PyString_FromString(pathname);
-		if (v == NULL)
-			PyErr_Clear();
-	}
-	if (v == NULL) {
-		v = ((PyCodeObject *)co)->co_filename;
-		Py_INCREF(v);
-	}
-	if (PyDict_SetItemString(d, "__file__", v) != 0)
-		PyErr_Clear(); /* Not important enough to report */
-	Py_DECREF(v);
-
-	v = PyEval_EvalCode((PyCodeObject *)co, d, d);
-	if (v == NULL)
-		goto error;
-	Py_DECREF(v);
-
-	if ((m = PyDict_GetItemString(modules, name)) == NULL) {
-		PyErr_Format(PyExc_ImportError,
-			     "Loaded module %.200s not found in sys.modules",
-			     name);
-		return NULL;
-	}
-
-	Py_INCREF(m);
-
-	return m;
+    PyObject *modules = PyImport_GetModuleDict();
+    PyObject *m, *d, *v;
+
+    m = PyImport_AddModule(name);
+    if (m == NULL)
+        return NULL;
+    /* If the module is being reloaded, we get the old module back
+       and re-use its dict to exec the new code. */
+    d = PyModule_GetDict(m);
+    if (PyDict_GetItemString(d, "__builtins__") == NULL) {
+        if (PyDict_SetItemString(d, "__builtins__",
+                                 PyEval_GetBuiltins()) != 0)
+            goto error;
+    }
+    /* Remember the filename as the __file__ attribute */
+    v = NULL;
+    if (pathname != NULL) {
+        v = PyString_FromString(pathname);
+        if (v == NULL)
+            PyErr_Clear();
+    }
+    if (v == NULL) {
+        v = ((PyCodeObject *)co)->co_filename;
+        Py_INCREF(v);
+    }
+    if (PyDict_SetItemString(d, "__file__", v) != 0)
+        PyErr_Clear(); /* Not important enough to report */
+    Py_DECREF(v);
+
+    v = PyEval_EvalCode((PyCodeObject *)co, d, d);
+    if (v == NULL)
+        goto error;
+    Py_DECREF(v);
+
+    if ((m = PyDict_GetItemString(modules, name)) == NULL) {
+        PyErr_Format(PyExc_ImportError,
+                     "Loaded module %.200s not found in sys.modules",
+                     name);
+        return NULL;
+    }
+
+    Py_INCREF(m);
+
+    return m;
 
   error:
-	remove_module(name);
-	return NULL;
+    remove_module(name);
+    return NULL;
 }
 
 
@@ -708,21 +708,21 @@ PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
 static char *
 make_compiled_pathname(char *pathname, char *buf, size_t buflen)
 {
-	size_t len = strlen(pathname);
-	if (len+2 > buflen)
-		return NULL;
+    size_t len = strlen(pathname);
+    if (len+2 > buflen)
+        return NULL;
 
 #ifdef MS_WINDOWS
-	/* Treat .pyw as if it were .py.  The case of ".pyw" must match
-	   that used in _PyImport_StandardFiletab. */
-	if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0)
-		--len;	/* pretend 'w' isn't there */
+    /* Treat .pyw as if it were .py.  The case of ".pyw" must match
+       that used in _PyImport_StandardFiletab. */
+    if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0)
+        --len;          /* pretend 'w' isn't there */
 #endif
-	memcpy(buf, pathname, len);
-	buf[len] = Py_OptimizeFlag ? 'o' : 'c';
-	buf[len+1] = '\0';
+    memcpy(buf, pathname, len);
+    buf[len] = Py_OptimizeFlag ? 'o' : 'c';
+    buf[len+1] = '\0';
 
-	return buf;
+    return buf;
 }
 
 
@@ -736,30 +736,30 @@ make_compiled_pathname(char *pathname, char *buf, size_t buflen)
 static FILE *
 check_compiled_module(char *pathname, time_t mtime, char *cpathname)
 {
-	FILE *fp;
-	long magic;
-	long pyc_mtime;
-
-	fp = fopen(cpathname, "rb");
-	if (fp == NULL)
-		return NULL;
-	magic = PyMarshal_ReadLongFromFile(fp);
-	if (magic != pyc_magic) {
-		if (Py_VerboseFlag)
-			PySys_WriteStderr("# %s has bad magic\n", cpathname);
-		fclose(fp);
-		return NULL;
-	}
-	pyc_mtime = PyMarshal_ReadLongFromFile(fp);
-	if (pyc_mtime != mtime) {
-		if (Py_VerboseFlag)
-			PySys_WriteStderr("# %s has bad mtime\n", cpathname);
-		fclose(fp);
-		return NULL;
-	}
-	if (Py_VerboseFlag)
-		PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
-	return fp;
+    FILE *fp;
+    long magic;
+    long pyc_mtime;
+
+    fp = fopen(cpathname, "rb");
+    if (fp == NULL)
+        return NULL;
+    magic = PyMarshal_ReadLongFromFile(fp);
+    if (magic != pyc_magic) {
+        if (Py_VerboseFlag)
+            PySys_WriteStderr("# %s has bad magic\n", cpathname);
+        fclose(fp);
+        return NULL;
+    }
+    pyc_mtime = PyMarshal_ReadLongFromFile(fp);
+    if (pyc_mtime != mtime) {
+        if (Py_VerboseFlag)
+            PySys_WriteStderr("# %s has bad mtime\n", cpathname);
+        fclose(fp);
+        return NULL;
+    }
+    if (Py_VerboseFlag)
+        PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
+    return fp;
 }
 
 
@@ -768,18 +768,18 @@ check_compiled_module(char *pathname, time_t mtime, char *cpathname)
 static PyCodeObject *
 read_compiled_module(char *cpathname, FILE *fp)
 {
-	PyObject *co;
+    PyObject *co;
 
-	co = PyMarshal_ReadLastObjectFromFile(fp);
-	if (co == NULL)
-		return NULL;
-	if (!PyCode_Check(co)) {
-		PyErr_Format(PyExc_ImportError,
-			     "Non-code object in %.200s", cpathname);
-		Py_DECREF(co);
-		return NULL;
-	}
-	return (PyCodeObject *)co;
+    co = PyMarshal_ReadLastObjectFromFile(fp);
+    if (co == NULL)
+        return NULL;
+    if (!PyCode_Check(co)) {
+        PyErr_Format(PyExc_ImportError,
+                     "Non-code object in %.200s", cpathname);
+        Py_DECREF(co);
+        return NULL;
+    }
+    return (PyCodeObject *)co;
 }
 
 
@@ -789,27 +789,27 @@ read_compiled_module(char *cpathname, FILE *fp)
 static PyObject *
 load_compiled_module(char *name, char *cpathname, FILE *fp)
 {
-	long magic;
-	PyCodeObject *co;
-	PyObject *m;
-
-	magic = PyMarshal_ReadLongFromFile(fp);
-	if (magic != pyc_magic) {
-		PyErr_Format(PyExc_ImportError,
-			     "Bad magic number in %.200s", cpathname);
-		return NULL;
-	}
-	(void) PyMarshal_ReadLongFromFile(fp);
-	co = read_compiled_module(cpathname, fp);
-	if (co == NULL)
-		return NULL;
-	if (Py_VerboseFlag)
-		PySys_WriteStderr("import %s # precompiled from %s\n",
-			name, cpathname);
-	m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname);
-	Py_DECREF(co);
-
-	return m;
+    long magic;
+    PyCodeObject *co;
+    PyObject *m;
+
+    magic = PyMarshal_ReadLongFromFile(fp);
+    if (magic != pyc_magic) {
+        PyErr_Format(PyExc_ImportError,
+                     "Bad magic number in %.200s", cpathname);
+        return NULL;
+    }
+    (void) PyMarshal_ReadLongFromFile(fp);
+    co = read_compiled_module(cpathname, fp);
+    if (co == NULL)
+        return NULL;
+    if (Py_VerboseFlag)
+        PySys_WriteStderr("import %s # precompiled from %s\n",
+            name, cpathname);
+    m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname);
+    Py_DECREF(co);
+
+    return m;
 }
 
 /* Parse a source file and return the corresponding code object */
@@ -817,22 +817,22 @@ load_compiled_module(char *name, char *cpathname, FILE *fp)
 static PyCodeObject *
 parse_source_module(const char *pathname, FILE *fp)
 {
-	PyCodeObject *co = NULL;
-	mod_ty mod;
-	PyCompilerFlags flags;
-	PyArena *arena = PyArena_New();
-	if (arena == NULL)
-		return NULL;
+    PyCodeObject *co = NULL;
+    mod_ty mod;
+    PyCompilerFlags flags;
+    PyArena *arena = PyArena_New();
+    if (arena == NULL)
+        return NULL;
 
-	flags.cf_flags = 0;
+    flags.cf_flags = 0;
 
-	mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, &flags,
-				   NULL, arena);
-	if (mod) {
-		co = PyAST_Compile(mod, pathname, NULL, arena);
-	}
-	PyArena_Free(arena);
-	return co;
+    mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, &flags,
+                               NULL, arena);
+    if (mod) {
+        co = PyAST_Compile(mod, pathname, NULL, arena);
+    }
+    PyArena_Free(arena);
+    return co;
 }
 
 
@@ -842,30 +842,30 @@ static FILE *
 open_exclusive(char *filename, mode_t mode)
 {
 #if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
-	/* Use O_EXCL to avoid a race condition when another process tries to
-	   write the same file.  When that happens, our open() call fails,
-	   which is just fine (since it's only a cache).
-	   XXX If the file exists and is writable but the directory is not
-	   writable, the file will never be written.  Oh well.
-	*/
-	int fd;
-	(void) unlink(filename);
-	fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC
+    /* Use O_EXCL to avoid a race condition when another process tries to
+       write the same file.  When that happens, our open() call fails,
+       which is just fine (since it's only a cache).
+       XXX If the file exists and is writable but the directory is not
+       writable, the file will never be written.  Oh well.
+    */
+    int fd;
+    (void) unlink(filename);
+    fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC
 #ifdef O_BINARY
-				|O_BINARY   /* necessary for Windows */
+                            |O_BINARY   /* necessary for Windows */
 #endif
 #ifdef __VMS
-                        , mode, "ctxt=bin", "shr=nil"
+            , mode, "ctxt=bin", "shr=nil"
 #else
-                        , mode
+            , mode
 #endif
-		  );
-	if (fd < 0)
-		return NULL;
-	return fdopen(fd, "wb");
+          );
+    if (fd < 0)
+        return NULL;
+    return fdopen(fd, "wb");
 #else
-	/* Best we can do -- on Windows this can't happen anyway */
-	return fopen(filename, "wb");
+    /* Best we can do -- on Windows this can't happen anyway */
+    return fopen(filename, "wb");
 #endif
 }
 
@@ -878,85 +878,85 @@ open_exclusive(char *filename, mode_t mode)
 static void
 write_compiled_module(PyCodeObject *co, char *cpathname, struct stat *srcstat)
 {
-	FILE *fp;
-	time_t mtime = srcstat->st_mtime;
+    FILE *fp;
+    time_t mtime = srcstat->st_mtime;
 #ifdef MS_WINDOWS   /* since Windows uses different permissions  */
-	mode_t mode = srcstat->st_mode & ~S_IEXEC;
+    mode_t mode = srcstat->st_mode & ~S_IEXEC;
 #else
-	mode_t mode = srcstat->st_mode & ~S_IXUSR & ~S_IXGRP & ~S_IXOTH;
+    mode_t mode = srcstat->st_mode & ~S_IXUSR & ~S_IXGRP & ~S_IXOTH;
 #endif
 
-	fp = open_exclusive(cpathname, mode);
-	if (fp == NULL) {
-		if (Py_VerboseFlag)
-			PySys_WriteStderr(
-				"# can't create %s\n", cpathname);
-		return;
-	}
-	PyMarshal_WriteLongToFile(pyc_magic, fp, Py_MARSHAL_VERSION);
-	/* First write a 0 for mtime */
-	PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
-	PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
-	if (fflush(fp) != 0 || ferror(fp)) {
-		if (Py_VerboseFlag)
-			PySys_WriteStderr("# can't write %s\n", cpathname);
-		/* Don't keep partial file */
-		fclose(fp);
-		(void) unlink(cpathname);
-		return;
-	}
-	/* Now write the true mtime */
-	fseek(fp, 4L, 0);
-	assert(mtime < LONG_MAX);
-	PyMarshal_WriteLongToFile((long)mtime, fp, Py_MARSHAL_VERSION);
-	fflush(fp);
-	fclose(fp);
-	if (Py_VerboseFlag)
-		PySys_WriteStderr("# wrote %s\n", cpathname);
+    fp = open_exclusive(cpathname, mode);
+    if (fp == NULL) {
+        if (Py_VerboseFlag)
+            PySys_WriteStderr(
+                "# can't create %s\n", cpathname);
+        return;
+    }
+    PyMarshal_WriteLongToFile(pyc_magic, fp, Py_MARSHAL_VERSION);
+    /* First write a 0 for mtime */
+    PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
+    PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
+    if (fflush(fp) != 0 || ferror(fp)) {
+        if (Py_VerboseFlag)
+            PySys_WriteStderr("# can't write %s\n", cpathname);
+        /* Don't keep partial file */
+        fclose(fp);
+        (void) unlink(cpathname);
+        return;
+    }
+    /* Now write the true mtime */
+    fseek(fp, 4L, 0);
+    assert(mtime < LONG_MAX);
+    PyMarshal_WriteLongToFile((long)mtime, fp, Py_MARSHAL_VERSION);
+    fflush(fp);
+    fclose(fp);
+    if (Py_VerboseFlag)
+        PySys_WriteStderr("# wrote %s\n", cpathname);
 }
 
 static void
 update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)
 {
-	PyObject *constants, *tmp;
-	Py_ssize_t i, n;
+    PyObject *constants, *tmp;
+    Py_ssize_t i, n;
 
-	if (!_PyString_Eq(co->co_filename, oldname))
-		return;
+    if (!_PyString_Eq(co->co_filename, oldname))
+        return;
 
-	tmp = co->co_filename;
-	co->co_filename = newname;
-	Py_INCREF(co->co_filename);
-	Py_DECREF(tmp);
+    tmp = co->co_filename;
+    co->co_filename = newname;
+    Py_INCREF(co->co_filename);
+    Py_DECREF(tmp);
 
-	constants = co->co_consts;
-	n = PyTuple_GET_SIZE(constants);
-	for (i = 0; i < n; i++) {
-		tmp = PyTuple_GET_ITEM(constants, i);
-		if (PyCode_Check(tmp))
-			update_code_filenames((PyCodeObject *)tmp,
-					      oldname, newname);
-	}
+    constants = co->co_consts;
+    n = PyTuple_GET_SIZE(constants);
+    for (i = 0; i < n; i++) {
+        tmp = PyTuple_GET_ITEM(constants, i);
+        if (PyCode_Check(tmp))
+            update_code_filenames((PyCodeObject *)tmp,
+                                  oldname, newname);
+    }
 }
 
 static int
 update_compiled_module(PyCodeObject *co, char *pathname)
 {
-	PyObject *oldname, *newname;
+    PyObject *oldname, *newname;
 
-	if (strcmp(PyString_AsString(co->co_filename), pathname) == 0)
-		return 0;
+    if (strcmp(PyString_AsString(co->co_filename), pathname) == 0)
+        return 0;
 
-	newname = PyString_FromString(pathname);
-	if (newname == NULL)
-		return -1;
+    newname = PyString_FromString(pathname);
+    if (newname == NULL)
+        return -1;
 
-	oldname = co->co_filename;
-	Py_INCREF(oldname);
-	update_code_filenames(co, oldname, newname);
-	Py_DECREF(oldname);
-	Py_DECREF(newname);
-	return 1;
+    oldname = co->co_filename;
+    Py_INCREF(oldname);
+    update_code_filenames(co, oldname, newname);
+    Py_DECREF(oldname);
+    Py_DECREF(newname);
+    return 1;
 }
 
 /* Load a source module from a given file and return its module
@@ -966,69 +966,69 @@ update_compiled_module(PyCodeObject *co, char *pathname)
 static PyObject *
 load_source_module(char *name, char *pathname, FILE *fp)
 {
-	struct stat st;
-	FILE *fpc;
-	char buf[MAXPATHLEN+1];
-	char *cpathname;
-	PyCodeObject *co;
-	PyObject *m;
-
-	if (fstat(fileno(fp), &st) != 0) {
-		PyErr_Format(PyExc_RuntimeError,
-			     "unable to get file status from '%s'",
-			     pathname);
-		return NULL;
-	}
+    struct stat st;
+    FILE *fpc;
+    char buf[MAXPATHLEN+1];
+    char *cpathname;
+    PyCodeObject *co;
+    PyObject *m;
+
+    if (fstat(fileno(fp), &st) != 0) {
+        PyErr_Format(PyExc_RuntimeError,
+                     "unable to get file status from '%s'",
+                     pathname);
+        return NULL;
+    }
 #if SIZEOF_TIME_T > 4
-	/* Python's .pyc timestamp handling presumes that the timestamp fits
-	   in 4 bytes. This will be fine until sometime in the year 2038,
-	   when a 4-byte signed time_t will overflow.
-	 */
-	if (st.st_mtime >> 32) {
-		PyErr_SetString(PyExc_OverflowError,
-			"modification time overflows a 4 byte field");
-		return NULL;
-	}
+    /* Python's .pyc timestamp handling presumes that the timestamp fits
+       in 4 bytes. This will be fine until sometime in the year 2038,
+       when a 4-byte signed time_t will overflow.
+     */
+    if (st.st_mtime >> 32) {
+        PyErr_SetString(PyExc_OverflowError,
+            "modification time overflows a 4 byte field");
+        return NULL;
+    }
 #endif
-	cpathname = make_compiled_pathname(pathname, buf,
-					   (size_t)MAXPATHLEN + 1);
-	if (cpathname != NULL &&
-	    (fpc = check_compiled_module(pathname, st.st_mtime, cpathname))) {
-		co = read_compiled_module(cpathname, fpc);
-		fclose(fpc);
-		if (co == NULL)
-			return NULL;
-		if (update_compiled_module(co, pathname) < 0)
-			return NULL;
-		if (Py_VerboseFlag)
-			PySys_WriteStderr("import %s # precompiled from %s\n",
-				name, cpathname);
-		pathname = cpathname;
-	}
-	else {
-		co = parse_source_module(pathname, fp);
-		if (co == NULL)
-			return NULL;
-		if (Py_VerboseFlag)
-			PySys_WriteStderr("import %s # from %s\n",
-				name, pathname);
-		if (cpathname) {
-			PyObject *ro = PySys_GetObject("dont_write_bytecode");
-			if (ro == NULL || !PyObject_IsTrue(ro))
-				write_compiled_module(co, cpathname, &st);
-		}
-	}
-	m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, pathname);
-	Py_DECREF(co);
-
-	return m;
+    cpathname = make_compiled_pathname(pathname, buf,
+                                       (size_t)MAXPATHLEN + 1);
+    if (cpathname != NULL &&
+        (fpc = check_compiled_module(pathname, st.st_mtime, cpathname))) {
+        co = read_compiled_module(cpathname, fpc);
+        fclose(fpc);
+        if (co == NULL)
+            return NULL;
+        if (update_compiled_module(co, pathname) < 0)
+            return NULL;
+        if (Py_VerboseFlag)
+            PySys_WriteStderr("import %s # precompiled from %s\n",
+                name, cpathname);
+        pathname = cpathname;
+    }
+    else {
+        co = parse_source_module(pathname, fp);
+        if (co == NULL)
+            return NULL;
+        if (Py_VerboseFlag)
+            PySys_WriteStderr("import %s # from %s\n",
+                name, pathname);
+        if (cpathname) {
+            PyObject *ro = PySys_GetObject("dont_write_bytecode");
+            if (ro == NULL || !PyObject_IsTrue(ro))
+                write_compiled_module(co, cpathname, &st);
+        }
+    }
+    m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, pathname);
+    Py_DECREF(co);
+
+    return m;
 }
 
 
 /* Forward */
 static PyObject *load_module(char *, FILE *, char *, int, PyObject *);
 static struct filedescr *find_module(char *, char *, PyObject *,
-				     char *, size_t, FILE **, PyObject **);
+                                     char *, size_t, FILE **, PyObject **);
 static struct _frozen *find_frozen(char *name);
 
 /* Load a package and return its module object WITH INCREMENTED
@@ -1037,54 +1037,54 @@ static struct _frozen *find_frozen(char *name);
 static PyObject *
 load_package(char *name, char *pathname)
 {
-	PyObject *m, *d;
-	PyObject *file = NULL;
-	PyObject *path = NULL;
-	int err;
-	char buf[MAXPATHLEN+1];
-	FILE *fp = NULL;
-	struct filedescr *fdp;
-
-	m = PyImport_AddModule(name);
-	if (m == NULL)
-		return NULL;
-	if (Py_VerboseFlag)
-		PySys_WriteStderr("import %s # directory %s\n",
-			name, pathname);
-	d = PyModule_GetDict(m);
-	file = PyString_FromString(pathname);
-	if (file == NULL)
-		goto error;
-	path = Py_BuildValue("[O]", file);
-	if (path == NULL)
-		goto error;
-	err = PyDict_SetItemString(d, "__file__", file);
-	if (err == 0)
-		err = PyDict_SetItemString(d, "__path__", path);
-	if (err != 0)
-		goto error;
-	buf[0] = '\0';
-	fdp = find_module(name, "__init__", path, buf, sizeof(buf), &fp, NULL);
-	if (fdp == NULL) {
-		if (PyErr_ExceptionMatches(PyExc_ImportError)) {
-			PyErr_Clear();
-			Py_INCREF(m);
-		}
-		else
-			m = NULL;
-		goto cleanup;
-	}
-	m = load_module(name, fp, buf, fdp->type, NULL);
-	if (fp != NULL)
-		fclose(fp);
-	goto cleanup;
+    PyObject *m, *d;
+    PyObject *file = NULL;
+    PyObject *path = NULL;
+    int err;
+    char buf[MAXPATHLEN+1];
+    FILE *fp = NULL;
+    struct filedescr *fdp;
+
+    m = PyImport_AddModule(name);
+    if (m == NULL)
+        return NULL;
+    if (Py_VerboseFlag)
+        PySys_WriteStderr("import %s # directory %s\n",
+            name, pathname);
+    d = PyModule_GetDict(m);
+    file = PyString_FromString(pathname);
+    if (file == NULL)
+        goto error;
+    path = Py_BuildValue("[O]", file);
+    if (path == NULL)
+        goto error;
+    err = PyDict_SetItemString(d, "__file__", file);
+    if (err == 0)
+        err = PyDict_SetItemString(d, "__path__", path);
+    if (err != 0)
+        goto error;
+    buf[0] = '\0';
+    fdp = find_module(name, "__init__", path, buf, sizeof(buf), &fp, NULL);
+    if (fdp == NULL) {
+        if (PyErr_ExceptionMatches(PyExc_ImportError)) {
+            PyErr_Clear();
+            Py_INCREF(m);
+        }
+        else
+            m = NULL;
+        goto cleanup;
+    }
+    m = load_module(name, fp, buf, fdp->type, NULL);
+    if (fp != NULL)
+        fclose(fp);
+    goto cleanup;
 
   error:
-  	m = NULL;
+    m = NULL;
   cleanup:
-	Py_XDECREF(path);
-	Py_XDECREF(file);
-	return m;
+    Py_XDECREF(path);
+    Py_XDECREF(file);
+    return m;
 }
 
 
@@ -1093,16 +1093,16 @@ load_package(char *name, char *pathname)
 static int
 is_builtin(char *name)
 {
-	int i;
-	for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
-		if (strcmp(name, PyImport_Inittab[i].name) == 0) {
-			if (PyImport_Inittab[i].initfunc == NULL)
-				return -1;
-			else
-				return 1;
-		}
-	}
-	return 0;
+    int i;
+    for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
+        if (strcmp(name, PyImport_Inittab[i].name) == 0) {
+            if (PyImport_Inittab[i].initfunc == NULL)
+                return -1;
+            else
+                return 1;
+        }
+    }
+    return 0;
 }
 
 
@@ -1116,72 +1116,72 @@ is_builtin(char *name)
 
 static PyObject *
 get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,
-		  PyObject *p)
-{
-	PyObject *importer;
-	Py_ssize_t j, nhooks;
-
-	/* These conditions are the caller's responsibility: */
-	assert(PyList_Check(path_hooks));
-	assert(PyDict_Check(path_importer_cache));
-
-	nhooks = PyList_Size(path_hooks);
-	if (nhooks < 0)
-		return NULL; /* Shouldn't happen */
-
-	importer = PyDict_GetItem(path_importer_cache, p);
-	if (importer != NULL)
-		return importer;
-
-	/* set path_importer_cache[p] to None to avoid recursion */
-	if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
-		return NULL;
-
-	for (j = 0; j < nhooks; j++) {
-		PyObject *hook = PyList_GetItem(path_hooks, j);
-		if (hook == NULL)
-			return NULL;
-		importer = PyObject_CallFunctionObjArgs(hook, p, NULL);
-		if (importer != NULL)
-			break;
-
-		if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
-			return NULL;
-		}
-		PyErr_Clear();
-	}
-	if (importer == NULL) {
-		importer = PyObject_CallFunctionObjArgs(
-			(PyObject *)&PyNullImporter_Type, p, NULL
-		);
-		if (importer == NULL) {
-			if (PyErr_ExceptionMatches(PyExc_ImportError)) {
-				PyErr_Clear();
-				return Py_None;
-			}
-		}
-	}
-	if (importer != NULL) {
-		int err = PyDict_SetItem(path_importer_cache, p, importer);
-		Py_DECREF(importer);
-		if (err != 0)
-			return NULL;
-	}
-	return importer;
+                  PyObject *p)
+{
+    PyObject *importer;
+    Py_ssize_t j, nhooks;
+
+    /* These conditions are the caller's responsibility: */
+    assert(PyList_Check(path_hooks));
+    assert(PyDict_Check(path_importer_cache));
+
+    nhooks = PyList_Size(path_hooks);
+    if (nhooks < 0)
+        return NULL; /* Shouldn't happen */
+
+    importer = PyDict_GetItem(path_importer_cache, p);
+    if (importer != NULL)
+        return importer;
+
+    /* set path_importer_cache[p] to None to avoid recursion */
+    if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
+        return NULL;
+
+    for (j = 0; j < nhooks; j++) {
+        PyObject *hook = PyList_GetItem(path_hooks, j);
+        if (hook == NULL)
+            return NULL;
+        importer = PyObject_CallFunctionObjArgs(hook, p, NULL);
+        if (importer != NULL)
+            break;
+
+        if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
+            return NULL;
+        }
+        PyErr_Clear();
+    }
+    if (importer == NULL) {
+        importer = PyObject_CallFunctionObjArgs(
+            (PyObject *)&PyNullImporter_Type, p, NULL
+        );
+        if (importer == NULL) {
+            if (PyErr_ExceptionMatches(PyExc_ImportError)) {
+                PyErr_Clear();
+                return Py_None;
+            }
+        }
+    }
+    if (importer != NULL) {
+        int err = PyDict_SetItem(path_importer_cache, p, importer);
+        Py_DECREF(importer);
+        if (err != 0)
+            return NULL;
+    }
+    return importer;
 }
 
 PyAPI_FUNC(PyObject *)
 PyImport_GetImporter(PyObject *path) {
-        PyObject *importer=NULL, *path_importer_cache=NULL, *path_hooks=NULL;
+    PyObject *importer=NULL, *path_importer_cache=NULL, *path_hooks=NULL;
 
-	if ((path_importer_cache = PySys_GetObject("path_importer_cache"))) {
-		if ((path_hooks = PySys_GetObject("path_hooks"))) {
-			importer = get_path_importer(path_importer_cache,
-			                             path_hooks, path);
-		}
-	}
-	Py_XINCREF(importer); /* get_path_importer returns a borrowed reference */
-	return importer;
+    if ((path_importer_cache = PySys_GetObject("path_importer_cache"))) {
+        if ((path_hooks = PySys_GetObject("path_hooks"))) {
+            importer = get_path_importer(path_importer_cache,
+                                         path_hooks, path);
+        }
+    }
+    Py_XINCREF(importer); /* get_path_importer returns a borrowed reference */
+    return importer;
 }
 
 /* Search the path (default sys.path) for a module.  Return the
@@ -1190,7 +1190,7 @@ PyImport_GetImporter(PyObject *path) {
 
 #ifdef MS_COREDLL
 extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **,
-					char *, Py_ssize_t);
+                                        char *, Py_ssize_t);
 #endif
 
 static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *);
@@ -1199,319 +1199,319 @@ static struct filedescr importhookdescr = {"", "", IMP_HOOK};
 
 static struct filedescr *
 find_module(char *fullname, char *subname, PyObject *path, char *buf,
-	    size_t buflen, FILE **p_fp, PyObject **p_loader)
-{
-	Py_ssize_t i, npath;
-	size_t len, namelen;
-	struct filedescr *fdp = NULL;
-	char *filemode;
-	FILE *fp = NULL;
-	PyObject *path_hooks, *path_importer_cache;
+            size_t buflen, FILE **p_fp, PyObject **p_loader)
+{
+    Py_ssize_t i, npath;
+    size_t len, namelen;
+    struct filedescr *fdp = NULL;
+    char *filemode;
+    FILE *fp = NULL;
+    PyObject *path_hooks, *path_importer_cache;
 #ifndef RISCOS
-	struct stat statbuf;
+    struct stat statbuf;
 #endif
-	static struct filedescr fd_frozen = {"", "", PY_FROZEN};
-	static struct filedescr fd_builtin = {"", "", C_BUILTIN};
-	static struct filedescr fd_package = {"", "", PKG_DIRECTORY};
-	char name[MAXPATHLEN+1];
+    static struct filedescr fd_frozen = {"", "", PY_FROZEN};
+    static struct filedescr fd_builtin = {"", "", C_BUILTIN};
+    static struct filedescr fd_package = {"", "", PKG_DIRECTORY};
+    char name[MAXPATHLEN+1];
 #if defined(PYOS_OS2)
-	size_t saved_len;
-	size_t saved_namelen;
-	char *saved_buf = NULL;
+    size_t saved_len;
+    size_t saved_namelen;
+    char *saved_buf = NULL;
 #endif
-	if (p_loader != NULL)
-		*p_loader = NULL;
-
-	if (strlen(subname) > MAXPATHLEN) {
-		PyErr_SetString(PyExc_OverflowError,
-				"module name is too long");
-		return NULL;
-	}
-	strcpy(name, subname);
-
-	/* sys.meta_path import hook */
-	if (p_loader != NULL) {
-		PyObject *meta_path;
-
-		meta_path = PySys_GetObject("meta_path");
-		if (meta_path == NULL || !PyList_Check(meta_path)) {
-			PyErr_SetString(PyExc_ImportError,
-					"sys.meta_path must be a list of "
-					"import hooks");
-			return NULL;
-		}
-		Py_INCREF(meta_path);  /* zap guard */
-		npath = PyList_Size(meta_path);
-		for (i = 0; i < npath; i++) {
-			PyObject *loader;
-			PyObject *hook = PyList_GetItem(meta_path, i);
-			loader = PyObject_CallMethod(hook, "find_module",
-						     "sO", fullname,
-						     path != NULL ?
-						     path : Py_None);
-			if (loader == NULL) {
-				Py_DECREF(meta_path);
-				return NULL;  /* true error */
-			}
-			if (loader != Py_None) {
-				/* a loader was found */
-				*p_loader = loader;
-				Py_DECREF(meta_path);
-				return &importhookdescr;
-			}
-			Py_DECREF(loader);
-		}
-		Py_DECREF(meta_path);
-	}
-
-	if (path != NULL && PyString_Check(path)) {
-		/* The only type of submodule allowed inside a "frozen"
-		   package are other frozen modules or packages. */
-		if (PyString_Size(path) + 1 + strlen(name) >= (size_t)buflen) {
-			PyErr_SetString(PyExc_ImportError,
-					"full frozen module name too long");
-			return NULL;
-		}
-		strcpy(buf, PyString_AsString(path));
-		strcat(buf, ".");
-		strcat(buf, name);
-		strcpy(name, buf);
-		if (find_frozen(name) != NULL) {
-			strcpy(buf, name);
-			return &fd_frozen;
-		}
-		PyErr_Format(PyExc_ImportError,
-			     "No frozen submodule named %.200s", name);
-		return NULL;
-	}
-	if (path == NULL) {
-		if (is_builtin(name)) {
-			strcpy(buf, name);
-			return &fd_builtin;
-		}
-		if ((find_frozen(name)) != NULL) {
-			strcpy(buf, name);
-			return &fd_frozen;
-		}
+    if (p_loader != NULL)
+        *p_loader = NULL;
+
+    if (strlen(subname) > MAXPATHLEN) {
+        PyErr_SetString(PyExc_OverflowError,
+                        "module name is too long");
+        return NULL;
+    }
+    strcpy(name, subname);
+
+    /* sys.meta_path import hook */
+    if (p_loader != NULL) {
+        PyObject *meta_path;
+
+        meta_path = PySys_GetObject("meta_path");
+        if (meta_path == NULL || !PyList_Check(meta_path)) {
+            PyErr_SetString(PyExc_ImportError,
+                            "sys.meta_path must be a list of "
+                            "import hooks");
+            return NULL;
+        }
+        Py_INCREF(meta_path);  /* zap guard */
+        npath = PyList_Size(meta_path);
+        for (i = 0; i < npath; i++) {
+            PyObject *loader;
+            PyObject *hook = PyList_GetItem(meta_path, i);
+            loader = PyObject_CallMethod(hook, "find_module",
+                                         "sO", fullname,
+                                         path != NULL ?
+                                         path : Py_None);
+            if (loader == NULL) {
+                Py_DECREF(meta_path);
+                return NULL;  /* true error */
+            }
+            if (loader != Py_None) {
+                /* a loader was found */
+                *p_loader = loader;
+                Py_DECREF(meta_path);
+                return &importhookdescr;
+            }
+            Py_DECREF(loader);
+        }
+        Py_DECREF(meta_path);
+    }
+
+    if (path != NULL && PyString_Check(path)) {
+        /* The only type of submodule allowed inside a "frozen"
+           package are other frozen modules or packages. */
+        if (PyString_Size(path) + 1 + strlen(name) >= (size_t)buflen) {
+            PyErr_SetString(PyExc_ImportError,
+                            "full frozen module name too long");
+            return NULL;
+        }
+        strcpy(buf, PyString_AsString(path));
+        strcat(buf, ".");
+        strcat(buf, name);
+        strcpy(name, buf);
+        if (find_frozen(name) != NULL) {
+            strcpy(buf, name);
+            return &fd_frozen;
+        }
+        PyErr_Format(PyExc_ImportError,
+                     "No frozen submodule named %.200s", name);
+        return NULL;
+    }
+    if (path == NULL) {
+        if (is_builtin(name)) {
+            strcpy(buf, name);
+            return &fd_builtin;
+        }
+        if ((find_frozen(name)) != NULL) {
+            strcpy(buf, name);
+            return &fd_frozen;
+        }
 
 #ifdef MS_COREDLL
-		fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen);
-		if (fp != NULL) {
-			*p_fp = fp;
-			return fdp;
-		}
+        fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen);
+        if (fp != NULL) {
+            *p_fp = fp;
+            return fdp;
+        }
 #endif
-		path = PySys_GetObject("path");
-	}
-	if (path == NULL || !PyList_Check(path)) {
-		PyErr_SetString(PyExc_ImportError,
-				"sys.path must be a list of directory names");
-		return NULL;
-	}
-
-	path_hooks = PySys_GetObject("path_hooks");
-	if (path_hooks == NULL || !PyList_Check(path_hooks)) {
-		PyErr_SetString(PyExc_ImportError,
-				"sys.path_hooks must be a list of "
-				"import hooks");
-		return NULL;
-	}
-	path_importer_cache = PySys_GetObject("path_importer_cache");
-	if (path_importer_cache == NULL ||
-	    !PyDict_Check(path_importer_cache)) {
-		PyErr_SetString(PyExc_ImportError,
-				"sys.path_importer_cache must be a dict");
-		return NULL;
-	}
-
-	npath = PyList_Size(path);
-	namelen = strlen(name);
-	for (i = 0; i < npath; i++) {
-		PyObject *copy = NULL;
-		PyObject *v = PyList_GetItem(path, i);
-		if (!v)
-			return NULL;
+        path = PySys_GetObject("path");
+    }
+    if (path == NULL || !PyList_Check(path)) {
+        PyErr_SetString(PyExc_ImportError,
+                        "sys.path must be a list of directory names");
+        return NULL;
+    }
+
+    path_hooks = PySys_GetObject("path_hooks");
+    if (path_hooks == NULL || !PyList_Check(path_hooks)) {
+        PyErr_SetString(PyExc_ImportError,
+                        "sys.path_hooks must be a list of "
+                        "import hooks");
+        return NULL;
+    }
+    path_importer_cache = PySys_GetObject("path_importer_cache");
+    if (path_importer_cache == NULL ||
+        !PyDict_Check(path_importer_cache)) {
+        PyErr_SetString(PyExc_ImportError,
+                        "sys.path_importer_cache must be a dict");
+        return NULL;
+    }
+
+    npath = PyList_Size(path);
+    namelen = strlen(name);
+    for (i = 0; i < npath; i++) {
+        PyObject *copy = NULL;
+        PyObject *v = PyList_GetItem(path, i);
+        if (!v)
+            return NULL;
 #ifdef Py_USING_UNICODE
-		if (PyUnicode_Check(v)) {
-			copy = PyUnicode_Encode(PyUnicode_AS_UNICODE(v),
-				PyUnicode_GET_SIZE(v), Py_FileSystemDefaultEncoding, NULL);
-			if (copy == NULL)
-				return NULL;
-			v = copy;
-		}
-		else
+        if (PyUnicode_Check(v)) {
+            copy = PyUnicode_Encode(PyUnicode_AS_UNICODE(v),
+                PyUnicode_GET_SIZE(v), Py_FileSystemDefaultEncoding, NULL);
+            if (copy == NULL)
+                return NULL;
+            v = copy;
+        }
+        else
 #endif
-		if (!PyString_Check(v))
-			continue;
-		len = PyString_GET_SIZE(v);
-		if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {
-			Py_XDECREF(copy);
-			continue; /* Too long */
-		}
-		strcpy(buf, PyString_AS_STRING(v));
-		if (strlen(buf) != len) {
-			Py_XDECREF(copy);
-			continue; /* v contains '\0' */
-		}
-
-		/* sys.path_hooks import hook */
-		if (p_loader != NULL) {
-			PyObject *importer;
-
-			importer = get_path_importer(path_importer_cache,
-						     path_hooks, v);
-			if (importer == NULL) {
-				Py_XDECREF(copy);
-				return NULL;
-			}
-			/* Note: importer is a borrowed reference */
-			if (importer != Py_None) {
-				PyObject *loader;
-				loader = PyObject_CallMethod(importer,
-							     "find_module",
-							     "s", fullname);
-				Py_XDECREF(copy);
-				if (loader == NULL)
-					return NULL;  /* error */
-				if (loader != Py_None) {
-					/* a loader was found */
-					*p_loader = loader;
-					return &importhookdescr;
-				}
-				Py_DECREF(loader);
-				continue;
-			}
-		}
-		/* no hook was found, use builtin import */
-
-		if (len > 0 && buf[len-1] != SEP
+        if (!PyString_Check(v))
+            continue;
+        len = PyString_GET_SIZE(v);
+        if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {
+            Py_XDECREF(copy);
+            continue; /* Too long */
+        }
+        strcpy(buf, PyString_AS_STRING(v));
+        if (strlen(buf) != len) {
+            Py_XDECREF(copy);
+            continue; /* v contains '\0' */
+        }
+
+        /* sys.path_hooks import hook */
+        if (p_loader != NULL) {
+            PyObject *importer;
+
+            importer = get_path_importer(path_importer_cache,
+                                         path_hooks, v);
+            if (importer == NULL) {
+                Py_XDECREF(copy);
+                return NULL;
+            }
+            /* Note: importer is a borrowed reference */
+            if (importer != Py_None) {
+                PyObject *loader;
+                loader = PyObject_CallMethod(importer,
+                                             "find_module",
+                                             "s", fullname);
+                Py_XDECREF(copy);
+                if (loader == NULL)
+                    return NULL;  /* error */
+                if (loader != Py_None) {
+                    /* a loader was found */
+                    *p_loader = loader;
+                    return &importhookdescr;
+                }
+                Py_DECREF(loader);
+                continue;
+            }
+        }
+        /* no hook was found, use builtin import */
+
+        if (len > 0 && buf[len-1] != SEP
 #ifdef ALTSEP
-		    && buf[len-1] != ALTSEP
+            && buf[len-1] != ALTSEP
 #endif
-		    )
-			buf[len++] = SEP;
-		strcpy(buf+len, name);
-		len += namelen;
+            )
+            buf[len++] = SEP;
+        strcpy(buf+len, name);
+        len += namelen;
 
-		/* Check for package import (buf holds a directory name,
-		   and there's an __init__ module in that directory */
+        /* Check for package import (buf holds a directory name,
+           and there's an __init__ module in that directory */
 #ifdef HAVE_STAT
-		if (stat(buf, &statbuf) == 0 &&         /* it exists */
-		    S_ISDIR(statbuf.st_mode) &&         /* it's a directory */
-		    case_ok(buf, len, namelen, name)) { /* case matches */
-			if (find_init_module(buf)) { /* and has __init__.py */
-				Py_XDECREF(copy);
-				return &fd_package;
-			}
-			else {
-				char warnstr[MAXPATHLEN+80];
-				sprintf(warnstr, "Not importing directory "
-					"'%.*s': missing __init__.py",
-					MAXPATHLEN, buf);
-				if (PyErr_Warn(PyExc_ImportWarning,
-					       warnstr)) {
-					Py_XDECREF(copy);
-					return NULL;
-				}
-			}
-		}
+        if (stat(buf, &statbuf) == 0 &&         /* it exists */
+            S_ISDIR(statbuf.st_mode) &&         /* it's a directory */
+            case_ok(buf, len, namelen, name)) { /* case matches */
+            if (find_init_module(buf)) { /* and has __init__.py */
+                Py_XDECREF(copy);
+                return &fd_package;
+            }
+            else {
+                char warnstr[MAXPATHLEN+80];
+                sprintf(warnstr, "Not importing directory "
+                    "'%.*s': missing __init__.py",
+                    MAXPATHLEN, buf);
+                if (PyErr_Warn(PyExc_ImportWarning,
+                               warnstr)) {
+                    Py_XDECREF(copy);
+                    return NULL;
+                }
+            }
+        }
 #else
-		/* XXX How are you going to test for directories? */
+        /* XXX How are you going to test for directories? */
 #ifdef RISCOS
-		if (isdir(buf) &&
-		    case_ok(buf, len, namelen, name)) {
-			if (find_init_module(buf)) {
-				Py_XDECREF(copy);
-				return &fd_package;
-			}
-			else {
-				char warnstr[MAXPATHLEN+80];
-				sprintf(warnstr, "Not importing directory "
-					"'%.*s': missing __init__.py",
-					MAXPATHLEN, buf);
-				if (PyErr_Warn(PyExc_ImportWarning,
-					       warnstr)) {
-					Py_XDECREF(copy);
-					return NULL;
-				}
-		}
+        if (isdir(buf) &&
+            case_ok(buf, len, namelen, name)) {
+            if (find_init_module(buf)) {
+                Py_XDECREF(copy);
+                return &fd_package;
+            }
+            else {
+                char warnstr[MAXPATHLEN+80];
+                sprintf(warnstr, "Not importing directory "
+                    "'%.*s': missing __init__.py",
+                    MAXPATHLEN, buf);
+                if (PyErr_Warn(PyExc_ImportWarning,
+                               warnstr)) {
+                    Py_XDECREF(copy);
+                    return NULL;
+                }
+        }
 #endif
 #endif
 #if defined(PYOS_OS2)
-		/* take a snapshot of the module spec for restoration
-		 * after the 8 character DLL hackery
-		 */
-		saved_buf = strdup(buf);
-		saved_len = len;
-		saved_namelen = namelen;
+        /* take a snapshot of the module spec for restoration
+         * after the 8 character DLL hackery
+         */
+        saved_buf = strdup(buf);
+        saved_len = len;
+        saved_namelen = namelen;
 #endif /* PYOS_OS2 */
-		for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
+        for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
 #if defined(PYOS_OS2) && defined(HAVE_DYNAMIC_LOADING)
-			/* OS/2 limits DLLs to 8 character names (w/o
-			   extension)
-			 * so if the name is longer than that and its a
-			 * dynamically loaded module we're going to try,
-			 * truncate the name before trying
-			 */
-			if (strlen(subname) > 8) {
-				/* is this an attempt to load a C extension? */
-				const struct filedescr *scan;
-				scan = _PyImport_DynLoadFiletab;
-				while (scan->suffix != NULL) {
-					if (!strcmp(scan->suffix, fdp->suffix))
-						break;
-					else
-						scan++;
-				}
-				if (scan->suffix != NULL) {
-					/* yes, so truncate the name */
-					namelen = 8;
-					len -= strlen(subname) - namelen;
-					buf[len] = '\0';
-				}
-			}
+            /* OS/2 limits DLLs to 8 character names (w/o
+               extension)
+             * so if the name is longer than that and its a
+             * dynamically loaded module we're going to try,
+             * truncate the name before trying
+             */
+            if (strlen(subname) > 8) {
+                /* is this an attempt to load a C extension? */
+                const struct filedescr *scan;
+                scan = _PyImport_DynLoadFiletab;
+                while (scan->suffix != NULL) {
+                    if (!strcmp(scan->suffix, fdp->suffix))
+                        break;
+                    else
+                        scan++;
+                }
+                if (scan->suffix != NULL) {
+                    /* yes, so truncate the name */
+                    namelen = 8;
+                    len -= strlen(subname) - namelen;
+                    buf[len] = '\0';
+                }
+            }
 #endif /* PYOS_OS2 */
-			strcpy(buf+len, fdp->suffix);
-			if (Py_VerboseFlag > 1)
-				PySys_WriteStderr("# trying %s\n", buf);
-			filemode = fdp->mode;
-			if (filemode[0] == 'U')
-				filemode = "r" PY_STDIOTEXTMODE;
-			fp = fopen(buf, filemode);
-			if (fp != NULL) {
-				if (case_ok(buf, len, namelen, name))
-					break;
-				else {	 /* continue search */
-					fclose(fp);
-					fp = NULL;
-				}
-			}
+            strcpy(buf+len, fdp->suffix);
+            if (Py_VerboseFlag > 1)
+                PySys_WriteStderr("# trying %s\n", buf);
+            filemode = fdp->mode;
+            if (filemode[0] == 'U')
+                filemode = "r" PY_STDIOTEXTMODE;
+            fp = fopen(buf, filemode);
+            if (fp != NULL) {
+                if (case_ok(buf, len, namelen, name))
+                    break;
+                else {                   /* continue search */
+                    fclose(fp);
+                    fp = NULL;
+                }
+            }
 #if defined(PYOS_OS2)
-			/* restore the saved snapshot */
-			strcpy(buf, saved_buf);
-			len = saved_len;
-			namelen = saved_namelen;
+            /* restore the saved snapshot */
+            strcpy(buf, saved_buf);
+            len = saved_len;
+            namelen = saved_namelen;
 #endif
-		}
+        }
 #if defined(PYOS_OS2)
-		/* don't need/want the module name snapshot anymore */
-		if (saved_buf)
-		{
-			free(saved_buf);
-			saved_buf = NULL;
-		}
+        /* don't need/want the module name snapshot anymore */
+        if (saved_buf)
+        {
+            free(saved_buf);
+            saved_buf = NULL;
+        }
 #endif
-		Py_XDECREF(copy);
-		if (fp != NULL)
-			break;
-	}
-	if (fp == NULL) {
-		PyErr_Format(PyExc_ImportError,
-			     "No module named %.200s", name);
-		return NULL;
-	}
-	*p_fp = fp;
-	return fdp;
+        Py_XDECREF(copy);
+        if (fp != NULL)
+            break;
+    }
+    if (fp == NULL) {
+        PyErr_Format(PyExc_ImportError,
+                     "No module named %.200s", name);
+        return NULL;
+    }
+    *p_fp = fp;
+    return fdp;
 }
 
 /* Helpers for main.c
@@ -1519,15 +1519,15 @@ find_module(char *fullname, char *subname, PyObject *path, char *buf,
  */
 struct filedescr *
 _PyImport_FindModule(const char *name, PyObject *path, char *buf,
-	    size_t buflen, FILE **p_fp, PyObject **p_loader)
+            size_t buflen, FILE **p_fp, PyObject **p_loader)
 {
-	return find_module((char *) name, (char *) name, path,
-			   buf, buflen, p_fp, p_loader);
+    return find_module((char *) name, (char *) name, path,
+                       buf, buflen, p_fp, p_loader);
 }
 
 PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr * fd)
 {
-	return fd->type == PY_SOURCE || fd->type == PY_COMPILED;
+    return fd->type == PY_SOURCE || fd->type == PY_COMPILED;
 }
 
 /* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
@@ -1586,128 +1586,128 @@ case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name)
 
 /* MS_WINDOWS */
 #if defined(MS_WINDOWS)
-	WIN32_FIND_DATA data;
-	HANDLE h;
-
-	if (Py_GETENV("PYTHONCASEOK") != NULL)
-		return 1;
-
-	h = FindFirstFile(buf, &data);
-	if (h == INVALID_HANDLE_VALUE) {
-		PyErr_Format(PyExc_NameError,
-		  "Can't find file for module %.100s\n(filename %.300s)",
-		  name, buf);
-		return 0;
-	}
-	FindClose(h);
-	return strncmp(data.cFileName, name, namelen) == 0;
+    WIN32_FIND_DATA data;
+    HANDLE h;
+
+    if (Py_GETENV("PYTHONCASEOK") != NULL)
+        return 1;
+
+    h = FindFirstFile(buf, &data);
+    if (h == INVALID_HANDLE_VALUE) {
+        PyErr_Format(PyExc_NameError,
+          "Can't find file for module %.100s\n(filename %.300s)",
+          name, buf);
+        return 0;
+    }
+    FindClose(h);
+    return strncmp(data.cFileName, name, namelen) == 0;
 
 /* DJGPP */
 #elif defined(DJGPP)
-	struct ffblk ffblk;
-	int done;
+    struct ffblk ffblk;
+    int done;
 
-	if (Py_GETENV("PYTHONCASEOK") != NULL)
-		return 1;
+    if (Py_GETENV("PYTHONCASEOK") != NULL)
+        return 1;
 
-	done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);
-	if (done) {
-		PyErr_Format(PyExc_NameError,
-		  "Can't find file for module %.100s\n(filename %.300s)",
-		  name, buf);
-		return 0;
-	}
-	return strncmp(ffblk.ff_name, name, namelen) == 0;
+    done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);
+    if (done) {
+        PyErr_Format(PyExc_NameError,
+          "Can't find file for module %.100s\n(filename %.300s)",
+          name, buf);
+        return 0;
+    }
+    return strncmp(ffblk.ff_name, name, namelen) == 0;
 
 /* new-fangled macintosh (macosx) or Cygwin */
 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
-	DIR *dirp;
-	struct dirent *dp;
-	char dirname[MAXPATHLEN + 1];
-	const int dirlen = len - namelen - 1; /* don't want trailing SEP */
-
-	if (Py_GETENV("PYTHONCASEOK") != NULL)
-		return 1;
-
-	/* Copy the dir component into dirname; substitute "." if empty */
-	if (dirlen <= 0) {
-		dirname[0] = '.';
-		dirname[1] = '\0';
-	}
-	else {
-		assert(dirlen <= MAXPATHLEN);
-		memcpy(dirname, buf, dirlen);
-		dirname[dirlen] = '\0';
-	}
-	/* Open the directory and search the entries for an exact match. */
-	dirp = opendir(dirname);
-	if (dirp) {
-		char *nameWithExt = buf + len - namelen;
-		while ((dp = readdir(dirp)) != NULL) {
-			const int thislen =
+    DIR *dirp;
+    struct dirent *dp;
+    char dirname[MAXPATHLEN + 1];
+    const int dirlen = len - namelen - 1; /* don't want trailing SEP */
+
+    if (Py_GETENV("PYTHONCASEOK") != NULL)
+        return 1;
+
+    /* Copy the dir component into dirname; substitute "." if empty */
+    if (dirlen <= 0) {
+        dirname[0] = '.';
+        dirname[1] = '\0';
+    }
+    else {
+        assert(dirlen <= MAXPATHLEN);
+        memcpy(dirname, buf, dirlen);
+        dirname[dirlen] = '\0';
+    }
+    /* Open the directory and search the entries for an exact match. */
+    dirp = opendir(dirname);
+    if (dirp) {
+        char *nameWithExt = buf + len - namelen;
+        while ((dp = readdir(dirp)) != NULL) {
+            const int thislen =
 #ifdef _DIRENT_HAVE_D_NAMELEN
-						dp->d_namlen;
+                                    dp->d_namlen;
 #else
-						strlen(dp->d_name);
+                                    strlen(dp->d_name);
 #endif
-			if (thislen >= namelen &&
-			    strcmp(dp->d_name, nameWithExt) == 0) {
-				(void)closedir(dirp);
-				return 1; /* Found */
-			}
-		}
-		(void)closedir(dirp);
-	}
-	return 0 ; /* Not found */
+            if (thislen >= namelen &&
+                strcmp(dp->d_name, nameWithExt) == 0) {
+                (void)closedir(dirp);
+                return 1; /* Found */
+            }
+        }
+        (void)closedir(dirp);
+    }
+    return 0 ; /* Not found */
 
 /* RISC OS */
 #elif defined(RISCOS)
-	char canon[MAXPATHLEN+1]; /* buffer for the canonical form of the path */
-	char buf2[MAXPATHLEN+2];
-	char *nameWithExt = buf+len-namelen;
-	int canonlen;
-	os_error *e;
+    char canon[MAXPATHLEN+1]; /* buffer for the canonical form of the path */
+    char buf2[MAXPATHLEN+2];
+    char *nameWithExt = buf+len-namelen;
+    int canonlen;
+    os_error *e;
 
-	if (Py_GETENV("PYTHONCASEOK") != NULL)
-		return 1;
+    if (Py_GETENV("PYTHONCASEOK") != NULL)
+        return 1;
 
-	/* workaround:
-	   append wildcard, otherwise case of filename wouldn't be touched */
-	strcpy(buf2, buf);
-	strcat(buf2, "*");
+    /* workaround:
+       append wildcard, otherwise case of filename wouldn't be touched */
+    strcpy(buf2, buf);
+    strcat(buf2, "*");
 
-	e = xosfscontrol_canonicalise_path(buf2,canon,0,0,MAXPATHLEN+1,&canonlen);
-	canonlen = MAXPATHLEN+1-canonlen;
-	if (e || canonlen<=0 || canonlen>(MAXPATHLEN+1) )
-		return 0;
-	if (strcmp(nameWithExt, canon+canonlen-strlen(nameWithExt))==0)
-		return 1; /* match */
+    e = xosfscontrol_canonicalise_path(buf2,canon,0,0,MAXPATHLEN+1,&canonlen);
+    canonlen = MAXPATHLEN+1-canonlen;
+    if (e || canonlen<=0 || canonlen>(MAXPATHLEN+1) )
+        return 0;
+    if (strcmp(nameWithExt, canon+canonlen-strlen(nameWithExt))==0)
+        return 1; /* match */
 
-	return 0;
+    return 0;
 
 /* OS/2 */
 #elif defined(PYOS_OS2)
-	HDIR hdir = 1;
-	ULONG srchcnt = 1;
-	FILEFINDBUF3 ffbuf;
-	APIRET rc;
-
-	if (Py_GETENV("PYTHONCASEOK") != NULL)
-		return 1;
-
-	rc = DosFindFirst(buf,
-			  &hdir,
-			  FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,
-			  &ffbuf, sizeof(ffbuf),
-			  &srchcnt,
-			  FIL_STANDARD);
-	if (rc != NO_ERROR)
-		return 0;
-	return strncmp(ffbuf.achName, name, namelen) == 0;
+    HDIR hdir = 1;
+    ULONG srchcnt = 1;
+    FILEFINDBUF3 ffbuf;
+    APIRET rc;
+
+    if (Py_GETENV("PYTHONCASEOK") != NULL)
+        return 1;
+
+    rc = DosFindFirst(buf,
+                      &hdir,
+                      FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,
+                      &ffbuf, sizeof(ffbuf),
+                      &srchcnt,
+                      FIL_STANDARD);
+    if (rc != NO_ERROR)
+        return 0;
+    return strncmp(ffbuf.achName, name, namelen) == 0;
 
 /* assuming it's a case-sensitive filesystem, so there's nothing to do! */
 #else
-	return 1;
+    return 1;
 
 #endif
 }
@@ -1718,46 +1718,46 @@ case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name)
 static int
 find_init_module(char *buf)
 {
-	const size_t save_len = strlen(buf);
-	size_t i = save_len;
-	char *pname;  /* pointer to start of __init__ */
-	struct stat statbuf;
-
-/*	For calling case_ok(buf, len, namelen, name):
- *	/a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
- *	^                      ^                   ^    ^
- *	|--------------------- buf ---------------------|
- *	|------------------- len ------------------|
- *	                       |------ name -------|
- *	                       |----- namelen -----|
+    const size_t save_len = strlen(buf);
+    size_t i = save_len;
+    char *pname;  /* pointer to start of __init__ */
+    struct stat statbuf;
+
+/*      For calling case_ok(buf, len, namelen, name):
+ *      /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
+ *      ^                      ^                   ^    ^
+ *      |--------------------- buf ---------------------|
+ *      |------------------- len ------------------|
+ *                             |------ name -------|
+ *                             |----- namelen -----|
  */
-	if (save_len + 13 >= MAXPATHLEN)
-		return 0;
-	buf[i++] = SEP;
-	pname = buf + i;
-	strcpy(pname, "__init__.py");
-	if (stat(buf, &statbuf) == 0) {
-		if (case_ok(buf,
-			    save_len + 9,	/* len("/__init__") */
-		            8,   		/* len("__init__") */
-		            pname)) {
-			buf[save_len] = '\0';
-			return 1;
-		}
-	}
-	i += strlen(pname);
-	strcpy(buf+i, Py_OptimizeFlag ? "o" : "c");
-	if (stat(buf, &statbuf) == 0) {
-		if (case_ok(buf,
-			    save_len + 9,	/* len("/__init__") */
-		            8,   		/* len("__init__") */
-		            pname)) {
-			buf[save_len] = '\0';
-			return 1;
-		}
-	}
-	buf[save_len] = '\0';
-	return 0;
+    if (save_len + 13 >= MAXPATHLEN)
+        return 0;
+    buf[i++] = SEP;
+    pname = buf + i;
+    strcpy(pname, "__init__.py");
+    if (stat(buf, &statbuf) == 0) {
+        if (case_ok(buf,
+                    save_len + 9,               /* len("/__init__") */
+                8,                              /* len("__init__") */
+                pname)) {
+            buf[save_len] = '\0';
+            return 1;
+        }
+    }
+    i += strlen(pname);
+    strcpy(buf+i, Py_OptimizeFlag ? "o" : "c");
+    if (stat(buf, &statbuf) == 0) {
+        if (case_ok(buf,
+                    save_len + 9,               /* len("/__init__") */
+                8,                              /* len("__init__") */
+                pname)) {
+            buf[save_len] = '\0';
+            return 1;
+        }
+    }
+    buf[save_len] = '\0';
+    return 0;
 }
 
 #else
@@ -1765,30 +1765,30 @@ find_init_module(char *buf)
 #ifdef RISCOS
 static int
 find_init_module(buf)
-	char *buf;
-{
-	int save_len = strlen(buf);
-	int i = save_len;
-
-	if (save_len + 13 >= MAXPATHLEN)
-		return 0;
-	buf[i++] = SEP;
-	strcpy(buf+i, "__init__/py");
-	if (isfile(buf)) {
-		buf[save_len] = '\0';
-		return 1;
-	}
-
-	if (Py_OptimizeFlag)
-		strcpy(buf+i, "o");
-	else
-		strcpy(buf+i, "c");
-	if (isfile(buf)) {
-		buf[save_len] = '\0';
-		return 1;
-	}
-	buf[save_len] = '\0';
-	return 0;
+    char *buf;
+{
+    int save_len = strlen(buf);
+    int i = save_len;
+
+    if (save_len + 13 >= MAXPATHLEN)
+        return 0;
+    buf[i++] = SEP;
+    strcpy(buf+i, "__init__/py");
+    if (isfile(buf)) {
+        buf[save_len] = '\0';
+        return 1;
+    }
+
+    if (Py_OptimizeFlag)
+        strcpy(buf+i, "o");
+    else
+        strcpy(buf+i, "c");
+    if (isfile(buf)) {
+        buf[save_len] = '\0';
+        return 1;
+    }
+    buf[save_len] = '\0';
+    return 0;
 }
 #endif /*RISCOS*/
 
@@ -1803,93 +1803,93 @@ static int init_builtin(char *); /* Forward */
 static PyObject *
 load_module(char *name, FILE *fp, char *pathname, int type, PyObject *loader)
 {
-	PyObject *modules;
-	PyObject *m;
-	int err;
+    PyObject *modules;
+    PyObject *m;
+    int err;
 
-	/* First check that there's an open file (if we need one)  */
-	switch (type) {
-	case PY_SOURCE:
-	case PY_COMPILED:
-		if (fp == NULL) {
-			PyErr_Format(PyExc_ValueError,
-			   "file object required for import (type code %d)",
-				     type);
-			return NULL;
-		}
-	}
+    /* First check that there's an open file (if we need one)  */
+    switch (type) {
+    case PY_SOURCE:
+    case PY_COMPILED:
+        if (fp == NULL) {
+            PyErr_Format(PyExc_ValueError,
+               "file object required for import (type code %d)",
+                         type);
+            return NULL;
+        }
+    }
 
-	switch (type) {
+    switch (type) {
 
-	case PY_SOURCE:
-		m = load_source_module(name, pathname, fp);
-		break;
+    case PY_SOURCE:
+        m = load_source_module(name, pathname, fp);
+        break;
 
-	case PY_COMPILED:
-		m = load_compiled_module(name, pathname, fp);
-		break;
+    case PY_COMPILED:
+        m = load_compiled_module(name, pathname, fp);
+        break;
 
 #ifdef HAVE_DYNAMIC_LOADING
-	case C_EXTENSION:
-		m = _PyImport_LoadDynamicModule(name, pathname, fp);
-		break;
+    case C_EXTENSION:
+        m = _PyImport_LoadDynamicModule(name, pathname, fp);
+        break;
 #endif
 
-	case PKG_DIRECTORY:
-		m = load_package(name, pathname);
-		break;
-
-	case C_BUILTIN:
-	case PY_FROZEN:
-		if (pathname != NULL && pathname[0] != '\0')
-			name = pathname;
-		if (type == C_BUILTIN)
-			err = init_builtin(name);
-		else
-			err = PyImport_ImportFrozenModule(name);
-		if (err < 0)
-			return NULL;
-		if (err == 0) {
-			PyErr_Format(PyExc_ImportError,
-				     "Purported %s module %.200s not found",
-				     type == C_BUILTIN ?
-						"builtin" : "frozen",
-				     name);
-			return NULL;
-		}
-		modules = PyImport_GetModuleDict();
-		m = PyDict_GetItemString(modules, name);
-		if (m == NULL) {
-			PyErr_Format(
-				PyExc_ImportError,
-				"%s module %.200s not properly initialized",
-				type == C_BUILTIN ?
-					"builtin" : "frozen",
-				name);
-			return NULL;
-		}
-		Py_INCREF(m);
-		break;
-
-	case IMP_HOOK: {
-		if (loader == NULL) {
-			PyErr_SetString(PyExc_ImportError,
-					"import hook without loader");
-			return NULL;
-		}
-		m = PyObject_CallMethod(loader, "load_module", "s", name);
-		break;
-	}
-
-	default:
-		PyErr_Format(PyExc_ImportError,
-			     "Don't know how to import %.200s (type code %d)",
-			      name, type);
-		m = NULL;
-
-	}
-
-	return m;
+    case PKG_DIRECTORY:
+        m = load_package(name, pathname);
+        break;
+
+    case C_BUILTIN:
+    case PY_FROZEN:
+        if (pathname != NULL && pathname[0] != '\0')
+            name = pathname;
+        if (type == C_BUILTIN)
+            err = init_builtin(name);
+        else
+            err = PyImport_ImportFrozenModule(name);
+        if (err < 0)
+            return NULL;
+        if (err == 0) {
+            PyErr_Format(PyExc_ImportError,
+                         "Purported %s module %.200s not found",
+                         type == C_BUILTIN ?
+                                    "builtin" : "frozen",
+                         name);
+            return NULL;
+        }
+        modules = PyImport_GetModuleDict();
+        m = PyDict_GetItemString(modules, name);
+        if (m == NULL) {
+            PyErr_Format(
+                PyExc_ImportError,
+                "%s module %.200s not properly initialized",
+                type == C_BUILTIN ?
+                    "builtin" : "frozen",
+                name);
+            return NULL;
+        }
+        Py_INCREF(m);
+        break;
+
+    case IMP_HOOK: {
+        if (loader == NULL) {
+            PyErr_SetString(PyExc_ImportError,
+                            "import hook without loader");
+            return NULL;
+        }
+        m = PyObject_CallMethod(loader, "load_module", "s", name);
+        break;
+    }
+
+    default:
+        PyErr_Format(PyExc_ImportError,
+                     "Don't know how to import %.200s (type code %d)",
+                      name, type);
+        m = NULL;
+
+    }
+
+    return m;
 }
 
 
@@ -1900,30 +1900,30 @@ load_module(char *name, FILE *fp, char *pathname, int type, PyObject *loader)
 static int
 init_builtin(char *name)
 {
-	struct _inittab *p;
-
-	if (_PyImport_FindExtension(name, name) != NULL)
-		return 1;
-
-	for (p = PyImport_Inittab; p->name != NULL; p++) {
-		if (strcmp(name, p->name) == 0) {
-			if (p->initfunc == NULL) {
-				PyErr_Format(PyExc_ImportError,
-				    "Cannot re-init internal module %.200s",
-				    name);
-				return -1;
-			}
-			if (Py_VerboseFlag)
-				PySys_WriteStderr("import %s # builtin\n", name);
-			(*p->initfunc)();
-			if (PyErr_Occurred())
-				return -1;
-			if (_PyImport_FixupExtension(name, name) == NULL)
-				return -1;
-			return 1;
-		}
-	}
-	return 0;
+    struct _inittab *p;
+
+    if (_PyImport_FindExtension(name, name) != NULL)
+        return 1;
+
+    for (p = PyImport_Inittab; p->name != NULL; p++) {
+        if (strcmp(name, p->name) == 0) {
+            if (p->initfunc == NULL) {
+                PyErr_Format(PyExc_ImportError,
+                    "Cannot re-init internal module %.200s",
+                    name);
+                return -1;
+            }
+            if (Py_VerboseFlag)
+                PySys_WriteStderr("import %s # builtin\n", name);
+            (*p->initfunc)();
+            if (PyErr_Occurred())
+                return -1;
+            if (_PyImport_FixupExtension(name, name) == NULL)
+                return -1;
+            return 1;
+        }
+    }
+    return 0;
 }
 
 
@@ -1932,39 +1932,39 @@ init_builtin(char *name)
 static struct _frozen *
 find_frozen(char *name)
 {
-	struct _frozen *p;
+    struct _frozen *p;
 
-	for (p = PyImport_FrozenModules; ; p++) {
-		if (p->name == NULL)
-			return NULL;
-		if (strcmp(p->name, name) == 0)
-			break;
-	}
-	return p;
+    for (p = PyImport_FrozenModules; ; p++) {
+        if (p->name == NULL)
+            return NULL;
+        if (strcmp(p->name, name) == 0)
+            break;
+    }
+    return p;
 }
 
 static PyObject *
 get_frozen_object(char *name)
 {
-	struct _frozen *p = find_frozen(name);
-	int size;
-
-	if (p == NULL) {
-		PyErr_Format(PyExc_ImportError,
-			     "No such frozen object named %.200s",
-			     name);
-		return NULL;
-	}
-	if (p->code == NULL) {
-		PyErr_Format(PyExc_ImportError,
-			     "Excluded frozen object named %.200s",
-			     name);
-		return NULL;
-	}
-	size = p->size;
-	if (size < 0)
-		size = -size;
-	return PyMarshal_ReadObjectFromString((char *)p->code, size);
+    struct _frozen *p = find_frozen(name);
+    int size;
+
+    if (p == NULL) {
+        PyErr_Format(PyExc_ImportError,
+                     "No such frozen object named %.200s",
+                     name);
+        return NULL;
+    }
+    if (p->code == NULL) {
+        PyErr_Format(PyExc_ImportError,
+                     "Excluded frozen object named %.200s",
+                     name);
+        return NULL;
+    }
+    size = p->size;
+    if (size < 0)
+        size = -size;
+    return PyMarshal_ReadObjectFromString((char *)p->code, size);
 }
 
 /* Initialize a frozen module.
@@ -1975,61 +1975,61 @@ get_frozen_object(char *name)
 int
 PyImport_ImportFrozenModule(char *name)
 {
-	struct _frozen *p = find_frozen(name);
-	PyObject *co;
-	PyObject *m;
-	int ispackage;
-	int size;
-
-	if (p == NULL)
-		return 0;
-	if (p->code == NULL) {
-		PyErr_Format(PyExc_ImportError,
-			     "Excluded frozen object named %.200s",
-			     name);
-		return -1;
-	}
-	size = p->size;
-	ispackage = (size < 0);
-	if (ispackage)
-		size = -size;
-	if (Py_VerboseFlag)
-		PySys_WriteStderr("import %s # frozen%s\n",
-			name, ispackage ? " package" : "");
-	co = PyMarshal_ReadObjectFromString((char *)p->code, size);
-	if (co == NULL)
-		return -1;
-	if (!PyCode_Check(co)) {
-		PyErr_Format(PyExc_TypeError,
-			     "frozen object %.200s is not a code object",
-			     name);
-		goto err_return;
-	}
-	if (ispackage) {
-		/* Set __path__ to the package name */
-		PyObject *d, *s;
-		int err;
-		m = PyImport_AddModule(name);
-		if (m == NULL)
-			goto err_return;
-		d = PyModule_GetDict(m);
-		s = PyString_InternFromString(name);
-		if (s == NULL)
-			goto err_return;
-		err = PyDict_SetItemString(d, "__path__", s);
-		Py_DECREF(s);
-		if (err != 0)
-			goto err_return;
-	}
-	m = PyImport_ExecCodeModuleEx(name, co, "<frozen>");
-	if (m == NULL)
-		goto err_return;
-	Py_DECREF(co);
-	Py_DECREF(m);
-	return 1;
+    struct _frozen *p = find_frozen(name);
+    PyObject *co;
+    PyObject *m;
+    int ispackage;
+    int size;
+
+    if (p == NULL)
+        return 0;
+    if (p->code == NULL) {
+        PyErr_Format(PyExc_ImportError,
+                     "Excluded frozen object named %.200s",
+                     name);
+        return -1;
+    }
+    size = p->size;
+    ispackage = (size < 0);
+    if (ispackage)
+        size = -size;
+    if (Py_VerboseFlag)
+        PySys_WriteStderr("import %s # frozen%s\n",
+            name, ispackage ? " package" : "");
+    co = PyMarshal_ReadObjectFromString((char *)p->code, size);
+    if (co == NULL)
+        return -1;
+    if (!PyCode_Check(co)) {
+        PyErr_Format(PyExc_TypeError,
+                     "frozen object %.200s is not a code object",
+                     name);
+        goto err_return;
+    }
+    if (ispackage) {
+        /* Set __path__ to the package name */
+        PyObject *d, *s;
+        int err;
+        m = PyImport_AddModule(name);
+        if (m == NULL)
+            goto err_return;
+        d = PyModule_GetDict(m);
+        s = PyString_InternFromString(name);
+        if (s == NULL)
+            goto err_return;
+        err = PyDict_SetItemString(d, "__path__", s);
+        Py_DECREF(s);
+        if (err != 0)
+            goto err_return;
+    }
+    m = PyImport_ExecCodeModuleEx(name, co, "<frozen>");
+    if (m == NULL)
+        goto err_return;
+    Py_DECREF(co);
+    Py_DECREF(m);
+    return 1;
 err_return:
-	Py_DECREF(co);
-	return -1;
+    Py_DECREF(co);
+    return -1;
 }
 
 
@@ -2039,15 +2039,15 @@ err_return:
 PyObject *
 PyImport_ImportModule(const char *name)
 {
-	PyObject *pname;
-	PyObject *result;
+    PyObject *pname;
+    PyObject *result;
 
-	pname = PyString_FromString(name);
-	if (pname == NULL)
-		return NULL;
-	result = PyImport_Import(pname);
-	Py_DECREF(pname);
-	return result;
+    pname = PyString_FromString(name);
+    if (pname == NULL)
+        return NULL;
+    result = PyImport_Import(pname);
+    Py_DECREF(pname);
+    return result;
 }
 
 /* Import a module without blocking
@@ -2062,137 +2062,137 @@ PyImport_ImportModule(const char *name)
 PyObject *
 PyImport_ImportModuleNoBlock(const char *name)
 {
-	PyObject *result;
-	PyObject *modules;
-	long me;
-
-	/* Try to get the module from sys.modules[name] */
-	modules = PyImport_GetModuleDict();
-	if (modules == NULL)
-		return NULL;
-
-	result = PyDict_GetItemString(modules, name);
-	if (result != NULL) {
-		Py_INCREF(result);
-		return result;
-	}
-	else {
-		PyErr_Clear();
-	}
+    PyObject *result;
+    PyObject *modules;
+    long me;
+
+    /* Try to get the module from sys.modules[name] */
+    modules = PyImport_GetModuleDict();
+    if (modules == NULL)
+        return NULL;
+
+    result = PyDict_GetItemString(modules, name);
+    if (result != NULL) {
+        Py_INCREF(result);
+        return result;
+    }
+    else {
+        PyErr_Clear();
+    }
 #ifdef WITH_THREAD
-	/* check the import lock
-	 * me might be -1 but I ignore the error here, the lock function
-	 * takes care of the problem */
-	me = PyThread_get_thread_ident();
-	if (import_lock_thread == -1 || import_lock_thread == me) {
-		/* no thread or me is holding the lock */
-		return PyImport_ImportModule(name);
-	}
-	else {
-		PyErr_Format(PyExc_ImportError,
-			     "Failed to import %.200s because the import lock"
-			     "is held by another thread.",
-			     name);
-		return NULL;
-	}
+    /* check the import lock
+     * me might be -1 but I ignore the error here, the lock function
+     * takes care of the problem */
+    me = PyThread_get_thread_ident();
+    if (import_lock_thread == -1 || import_lock_thread == me) {
+        /* no thread or me is holding the lock */
+        return PyImport_ImportModule(name);
+    }
+    else {
+        PyErr_Format(PyExc_ImportError,
+                     "Failed to import %.200s because the import lock"
+                     "is held by another thread.",
+                     name);
+        return NULL;
+    }
 #else
-	return PyImport_ImportModule(name);
+    return PyImport_ImportModule(name);
 #endif
 }
 
 /* Forward declarations for helper routines */
 static PyObject *get_parent(PyObject *globals, char *buf,
-			    Py_ssize_t *p_buflen, int level);
+                            Py_ssize_t *p_buflen, int level);
 static PyObject *load_next(PyObject *mod, PyObject *altmod,
-			   char **p_name, char *buf, Py_ssize_t *p_buflen);
+                           char **p_name, char *buf, Py_ssize_t *p_buflen);
 static int mark_miss(char *name);
 static int ensure_fromlist(PyObject *mod, PyObject *fromlist,
-			   char *buf, Py_ssize_t buflen, int recursive);
+                           char *buf, Py_ssize_t buflen, int recursive);
 static PyObject * import_submodule(PyObject *mod, char *name, char *fullname);
 
 /* The Magnum Opus of dotted-name import :-) */
 
 static PyObject *
 import_module_level(char *name, PyObject *globals, PyObject *locals,
-		    PyObject *fromlist, int level)
+                    PyObject *fromlist, int level)
 {
-	char buf[MAXPATHLEN+1];
-	Py_ssize_t buflen = 0;
-	PyObject *parent, *head, *next, *tail;
+    char buf[MAXPATHLEN+1];
+    Py_ssize_t buflen = 0;
+    PyObject *parent, *head, *next, *tail;
 
-	if (strchr(name, '/') != NULL
+    if (strchr(name, '/') != NULL
 #ifdef MS_WINDOWS
-	    || strchr(name, '\\') != NULL
+        || strchr(name, '\\') != NULL
 #endif
-		) {
-		PyErr_SetString(PyExc_ImportError,
-				"Import by filename is not supported.");
-		return NULL;
-	}
-
-	parent = get_parent(globals, buf, &buflen, level);
-	if (parent == NULL)
-		return NULL;
-
-	head = load_next(parent, Py_None, &name, buf, &buflen);
-	if (head == NULL)
-		return NULL;
-
-	tail = head;
-	Py_INCREF(tail);
-	while (name) {
-		next = load_next(tail, tail, &name, buf, &buflen);
-		Py_DECREF(tail);
-		if (next == NULL) {
-			Py_DECREF(head);
-			return NULL;
-		}
-		tail = next;
-	}
-	if (tail == Py_None) {
-		/* If tail is Py_None, both get_parent and load_next found
-		   an empty module name: someone called __import__("") or
-		   doctored faulty bytecode */
-		Py_DECREF(tail);
-		Py_DECREF(head);
-		PyErr_SetString(PyExc_ValueError,
-				"Empty module name");
-		return NULL;
-	}
-
-	if (fromlist != NULL) {
-		if (fromlist == Py_None || !PyObject_IsTrue(fromlist))
-			fromlist = NULL;
-	}
-
-	if (fromlist == NULL) {
-		Py_DECREF(tail);
-		return head;
-	}
-
-	Py_DECREF(head);
-	if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {
-		Py_DECREF(tail);
-		return NULL;
-	}
-
-	return tail;
+        ) {
+        PyErr_SetString(PyExc_ImportError,
+                        "Import by filename is not supported.");
+        return NULL;
+    }
+
+    parent = get_parent(globals, buf, &buflen, level);
+    if (parent == NULL)
+        return NULL;
+
+    head = load_next(parent, Py_None, &name, buf, &buflen);
+    if (head == NULL)
+        return NULL;
+
+    tail = head;
+    Py_INCREF(tail);
+    while (name) {
+        next = load_next(tail, tail, &name, buf, &buflen);
+        Py_DECREF(tail);
+        if (next == NULL) {
+            Py_DECREF(head);
+            return NULL;
+        }
+        tail = next;
+    }
+    if (tail == Py_None) {
+        /* If tail is Py_None, both get_parent and load_next found
+           an empty module name: someone called __import__("") or
+           doctored faulty bytecode */
+        Py_DECREF(tail);
+        Py_DECREF(head);
+        PyErr_SetString(PyExc_ValueError,
+                        "Empty module name");
+        return NULL;
+    }
+
+    if (fromlist != NULL) {
+        if (fromlist == Py_None || !PyObject_IsTrue(fromlist))
+            fromlist = NULL;
+    }
+
+    if (fromlist == NULL) {
+        Py_DECREF(tail);
+        return head;
+    }
+
+    Py_DECREF(head);
+    if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {
+        Py_DECREF(tail);
+        return NULL;
+    }
+
+    return tail;
 }
 
 PyObject *
 PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,
-			 PyObject *fromlist, int level)
+                         PyObject *fromlist, int level)
 {
-	PyObject *result;
-	_PyImport_AcquireLock();
-	result = import_module_level(name, globals, locals, fromlist, level);
-	if (_PyImport_ReleaseLock() < 0) {
-		Py_XDECREF(result);
-		PyErr_SetString(PyExc_RuntimeError,
-				"not holding the import lock");
-		return NULL;
-	}
-	return result;
+    PyObject *result;
+    _PyImport_AcquireLock();
+    result = import_module_level(name, globals, locals, fromlist, level);
+    if (_PyImport_ReleaseLock() < 0) {
+        Py_XDECREF(result);
+        PyErr_SetString(PyExc_RuntimeError,
+                        "not holding the import lock");
+        return NULL;
+    }
+    return result;
 }
 
 /* Return the package that an import is being performed in.  If globals comes
@@ -2209,400 +2209,400 @@ PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,
 static PyObject *
 get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen, int level)
 {
-	static PyObject *namestr = NULL;
-	static PyObject *pathstr = NULL;
-	static PyObject *pkgstr = NULL;
-	PyObject *pkgname, *modname, *modpath, *modules, *parent;
-	int orig_level = level;
-
-	if (globals == NULL || !PyDict_Check(globals) || !level)
-		return Py_None;
-
-	if (namestr == NULL) {
-		namestr = PyString_InternFromString("__name__");
-		if (namestr == NULL)
-			return NULL;
-	}
-	if (pathstr == NULL) {
-		pathstr = PyString_InternFromString("__path__");
-		if (pathstr == NULL)
-			return NULL;
-	}
-	if (pkgstr == NULL) {
-		pkgstr = PyString_InternFromString("__package__");
-		if (pkgstr == NULL)
-			return NULL;
-	}
-
-	*buf = '\0';
-	*p_buflen = 0;
-	pkgname = PyDict_GetItem(globals, pkgstr);
-
-	if ((pkgname != NULL) && (pkgname != Py_None)) {
-		/* __package__ is set, so use it */
-		Py_ssize_t len;
-		if (!PyString_Check(pkgname)) {
-			PyErr_SetString(PyExc_ValueError,
-					"__package__ set to non-string");
-			return NULL;
-		}
-		len = PyString_GET_SIZE(pkgname);
-		if (len == 0) {
-			if (level > 0) {
-				PyErr_SetString(PyExc_ValueError,
-					"Attempted relative import in non-package");
-				return NULL;
-			}
-			return Py_None;
-		}
-		if (len > MAXPATHLEN) {
-			PyErr_SetString(PyExc_ValueError,
-					"Package name too long");
-			return NULL;
-		}
-		strcpy(buf, PyString_AS_STRING(pkgname));
-	} else {
-		/* __package__ not set, so figure it out and set it */
-		modname = PyDict_GetItem(globals, namestr);
-		if (modname == NULL || !PyString_Check(modname))
-			return Py_None;
-
-		modpath = PyDict_GetItem(globals, pathstr);
-		if (modpath != NULL) {
-			/* __path__ is set, so modname is already the package name */
-			Py_ssize_t len = PyString_GET_SIZE(modname);
-			int error;
-			if (len > MAXPATHLEN) {
-				PyErr_SetString(PyExc_ValueError,
-						"Module name too long");
-				return NULL;
-			}
-			strcpy(buf, PyString_AS_STRING(modname));
-			error = PyDict_SetItem(globals, pkgstr, modname);
-			if (error) {
-				PyErr_SetString(PyExc_ValueError,
-						"Could not set __package__");
-				return NULL;
-			}
-		} else {
-			/* Normal module, so work out the package name if any */
-			char *start = PyString_AS_STRING(modname);
-			char *lastdot = strrchr(start, '.');
-			size_t len;
-			int error;
-			if (lastdot == NULL && level > 0) {
-				PyErr_SetString(PyExc_ValueError,
-					"Attempted relative import in non-package");
-				return NULL;
-			}
-			if (lastdot == NULL) {
-				error = PyDict_SetItem(globals, pkgstr, Py_None);
-				if (error) {
-					PyErr_SetString(PyExc_ValueError,
-						"Could not set __package__");
-					return NULL;
-				}
-				return Py_None;
-			}
-			len = lastdot - start;
-			if (len >= MAXPATHLEN) {
-				PyErr_SetString(PyExc_ValueError,
-						"Module name too long");
-				return NULL;
-			}
-			strncpy(buf, start, len);
-			buf[len] = '\0';
-			pkgname = PyString_FromString(buf);
-			if (pkgname == NULL) {
-				return NULL;
-			}
-			error = PyDict_SetItem(globals, pkgstr, pkgname);
-			Py_DECREF(pkgname);
-			if (error) {
-				PyErr_SetString(PyExc_ValueError,
-						"Could not set __package__");
-				return NULL;
-			}
-		}
-	}
-	while (--level > 0) {
-		char *dot = strrchr(buf, '.');
-		if (dot == NULL) {
-			PyErr_SetString(PyExc_ValueError,
-				"Attempted relative import beyond "
-				"toplevel package");
-			return NULL;
-		}
-		*dot = '\0';
-	}
-	*p_buflen = strlen(buf);
-
-	modules = PyImport_GetModuleDict();
-	parent = PyDict_GetItemString(modules, buf);
-	if (parent == NULL) {
-		if (orig_level < 1) {
-			PyObject *err_msg = PyString_FromFormat(
-				"Parent module '%.200s' not found "
-				"while handling absolute import", buf);
-			if (err_msg == NULL) {
-				return NULL;
-			}
-			if (!PyErr_WarnEx(PyExc_RuntimeWarning,
-					PyString_AsString(err_msg), 1)) {
-				*buf = '\0';
-				*p_buflen = 0;
-				parent = Py_None;
-			}
-			Py_DECREF(err_msg);
-		} else {
-			PyErr_Format(PyExc_SystemError,
-				"Parent module '%.200s' not loaded, "
-				"cannot perform relative import", buf);
-		}
-	}
-	return parent;
-	/* We expect, but can't guarantee, if parent != None, that:
-	   - parent.__name__ == buf
-	   - parent.__dict__ is globals
-	   If this is violated...  Who cares? */
+    static PyObject *namestr = NULL;
+    static PyObject *pathstr = NULL;
+    static PyObject *pkgstr = NULL;
+    PyObject *pkgname, *modname, *modpath, *modules, *parent;
+    int orig_level = level;
+
+    if (globals == NULL || !PyDict_Check(globals) || !level)
+        return Py_None;
+
+    if (namestr == NULL) {
+        namestr = PyString_InternFromString("__name__");
+        if (namestr == NULL)
+            return NULL;
+    }
+    if (pathstr == NULL) {
+        pathstr = PyString_InternFromString("__path__");
+        if (pathstr == NULL)
+            return NULL;
+    }
+    if (pkgstr == NULL) {
+        pkgstr = PyString_InternFromString("__package__");
+        if (pkgstr == NULL)
+            return NULL;
+    }
+
+    *buf = '\0';
+    *p_buflen = 0;
+    pkgname = PyDict_GetItem(globals, pkgstr);
+
+    if ((pkgname != NULL) && (pkgname != Py_None)) {
+        /* __package__ is set, so use it */
+        Py_ssize_t len;
+        if (!PyString_Check(pkgname)) {
+            PyErr_SetString(PyExc_ValueError,
+                            "__package__ set to non-string");
+            return NULL;
+        }
+        len = PyString_GET_SIZE(pkgname);
+        if (len == 0) {
+            if (level > 0) {
+                PyErr_SetString(PyExc_ValueError,
+                    "Attempted relative import in non-package");
+                return NULL;
+            }
+            return Py_None;
+        }
+        if (len > MAXPATHLEN) {
+            PyErr_SetString(PyExc_ValueError,
+                            "Package name too long");
+            return NULL;
+        }
+        strcpy(buf, PyString_AS_STRING(pkgname));
+    } else {
+        /* __package__ not set, so figure it out and set it */
+        modname = PyDict_GetItem(globals, namestr);
+        if (modname == NULL || !PyString_Check(modname))
+            return Py_None;
+
+        modpath = PyDict_GetItem(globals, pathstr);
+        if (modpath != NULL) {
+            /* __path__ is set, so modname is already the package name */
+            Py_ssize_t len = PyString_GET_SIZE(modname);
+            int error;
+            if (len > MAXPATHLEN) {
+                PyErr_SetString(PyExc_ValueError,
+                                "Module name too long");
+                return NULL;
+            }
+            strcpy(buf, PyString_AS_STRING(modname));
+            error = PyDict_SetItem(globals, pkgstr, modname);
+            if (error) {
+                PyErr_SetString(PyExc_ValueError,
+                                "Could not set __package__");
+                return NULL;
+            }
+        } else {
+            /* Normal module, so work out the package name if any */
+            char *start = PyString_AS_STRING(modname);
+            char *lastdot = strrchr(start, '.');
+            size_t len;
+            int error;
+            if (lastdot == NULL && level > 0) {
+                PyErr_SetString(PyExc_ValueError,
+                    "Attempted relative import in non-package");
+                return NULL;
+            }
+            if (lastdot == NULL) {
+                error = PyDict_SetItem(globals, pkgstr, Py_None);
+                if (error) {
+                    PyErr_SetString(PyExc_ValueError,
+                        "Could not set __package__");
+                    return NULL;
+                }
+                return Py_None;
+            }
+            len = lastdot - start;
+            if (len >= MAXPATHLEN) {
+                PyErr_SetString(PyExc_ValueError,
+                                "Module name too long");
+                return NULL;
+            }
+            strncpy(buf, start, len);
+            buf[len] = '\0';
+            pkgname = PyString_FromString(buf);
+            if (pkgname == NULL) {
+                return NULL;
+            }
+            error = PyDict_SetItem(globals, pkgstr, pkgname);
+            Py_DECREF(pkgname);
+            if (error) {
+                PyErr_SetString(PyExc_ValueError,
+                                "Could not set __package__");
+                return NULL;
+            }
+        }
+    }
+    while (--level > 0) {
+        char *dot = strrchr(buf, '.');
+        if (dot == NULL) {
+            PyErr_SetString(PyExc_ValueError,
+                "Attempted relative import beyond "
+                "toplevel package");
+            return NULL;
+        }
+        *dot = '\0';
+    }
+    *p_buflen = strlen(buf);
+
+    modules = PyImport_GetModuleDict();
+    parent = PyDict_GetItemString(modules, buf);
+    if (parent == NULL) {
+        if (orig_level < 1) {
+            PyObject *err_msg = PyString_FromFormat(
+                "Parent module '%.200s' not found "
+                "while handling absolute import", buf);
+            if (err_msg == NULL) {
+                return NULL;
+            }
+            if (!PyErr_WarnEx(PyExc_RuntimeWarning,
+                            PyString_AsString(err_msg), 1)) {
+                *buf = '\0';
+                *p_buflen = 0;
+                parent = Py_None;
+            }
+            Py_DECREF(err_msg);
+        } else {
+            PyErr_Format(PyExc_SystemError,
+                "Parent module '%.200s' not loaded, "
+                "cannot perform relative import", buf);
+        }
+    }
+    return parent;
+    /* We expect, but can't guarantee, if parent != None, that:
+       - parent.__name__ == buf
+       - parent.__dict__ is globals
+       If this is violated...  Who cares? */
 }
 
 /* altmod is either None or same as mod */
 static PyObject *
 load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf,
-	  Py_ssize_t *p_buflen)
-{
-	char *name = *p_name;
-	char *dot = strchr(name, '.');
-	size_t len;
-	char *p;
-	PyObject *result;
-
-	if (strlen(name) == 0) {
-		/* completely empty module name should only happen in
-		   'from . import' (or '__import__("")')*/
-		Py_INCREF(mod);
-		*p_name = NULL;
-		return mod;
-	}
-
-	if (dot == NULL) {
-		*p_name = NULL;
-		len = strlen(name);
-	}
-	else {
-		*p_name = dot+1;
-		len = dot-name;
-	}
-	if (len == 0) {
-		PyErr_SetString(PyExc_ValueError,
-				"Empty module name");
-		return NULL;
-	}
-
-	p = buf + *p_buflen;
-	if (p != buf)
-		*p++ = '.';
-	if (p+len-buf >= MAXPATHLEN) {
-		PyErr_SetString(PyExc_ValueError,
-				"Module name too long");
-		return NULL;
-	}
-	strncpy(p, name, len);
-	p[len] = '\0';
-	*p_buflen = p+len-buf;
-
-	result = import_submodule(mod, p, buf);
-	if (result == Py_None && altmod != mod) {
-		Py_DECREF(result);
-		/* Here, altmod must be None and mod must not be None */
-		result = import_submodule(altmod, p, p);
-		if (result != NULL && result != Py_None) {
-			if (mark_miss(buf) != 0) {
-				Py_DECREF(result);
-				return NULL;
-			}
-			strncpy(buf, name, len);
-			buf[len] = '\0';
-			*p_buflen = len;
-		}
-	}
-	if (result == NULL)
-		return NULL;
-
-	if (result == Py_None) {
-		Py_DECREF(result);
-		PyErr_Format(PyExc_ImportError,
-			     "No module named %.200s", name);
-		return NULL;
-	}
-
-	return result;
+          Py_ssize_t *p_buflen)
+{
+    char *name = *p_name;
+    char *dot = strchr(name, '.');
+    size_t len;
+    char *p;
+    PyObject *result;
+
+    if (strlen(name) == 0) {
+        /* completely empty module name should only happen in
+           'from . import' (or '__import__("")')*/
+        Py_INCREF(mod);
+        *p_name = NULL;
+        return mod;
+    }
+
+    if (dot == NULL) {
+        *p_name = NULL;
+        len = strlen(name);
+    }
+    else {
+        *p_name = dot+1;
+        len = dot-name;
+    }
+    if (len == 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Empty module name");
+        return NULL;
+    }
+
+    p = buf + *p_buflen;
+    if (p != buf)
+        *p++ = '.';
+    if (p+len-buf >= MAXPATHLEN) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Module name too long");
+        return NULL;
+    }
+    strncpy(p, name, len);
+    p[len] = '\0';
+    *p_buflen = p+len-buf;
+
+    result = import_submodule(mod, p, buf);
+    if (result == Py_None && altmod != mod) {
+        Py_DECREF(result);
+        /* Here, altmod must be None and mod must not be None */
+        result = import_submodule(altmod, p, p);
+        if (result != NULL && result != Py_None) {
+            if (mark_miss(buf) != 0) {
+                Py_DECREF(result);
+                return NULL;
+            }
+            strncpy(buf, name, len);
+            buf[len] = '\0';
+            *p_buflen = len;
+        }
+    }
+    if (result == NULL)
+        return NULL;
+
+    if (result == Py_None) {
+        Py_DECREF(result);
+        PyErr_Format(PyExc_ImportError,
+                     "No module named %.200s", name);
+        return NULL;
+    }
+
+    return result;
 }
 
 static int
 mark_miss(char *name)
 {
-	PyObject *modules = PyImport_GetModuleDict();
-	return PyDict_SetItemString(modules, name, Py_None);
+    PyObject *modules = PyImport_GetModuleDict();
+    return PyDict_SetItemString(modules, name, Py_None);
 }
 
 static int
 ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen,
-		int recursive)
-{
-	int i;
-
-	if (!PyObject_HasAttrString(mod, "__path__"))
-		return 1;
-
-	for (i = 0; ; i++) {
-		PyObject *item = PySequence_GetItem(fromlist, i);
-		int hasit;
-		if (item == NULL) {
-			if (PyErr_ExceptionMatches(PyExc_IndexError)) {
-				PyErr_Clear();
-				return 1;
-			}
-			return 0;
-		}
-		if (!PyString_Check(item)) {
-			PyErr_SetString(PyExc_TypeError,
-					"Item in ``from list'' not a string");
-			Py_DECREF(item);
-			return 0;
-		}
-		if (PyString_AS_STRING(item)[0] == '*') {
-			PyObject *all;
-			Py_DECREF(item);
-			/* See if the package defines __all__ */
-			if (recursive)
-				continue; /* Avoid endless recursion */
-			all = PyObject_GetAttrString(mod, "__all__");
-			if (all == NULL)
-				PyErr_Clear();
-			else {
-				int ret = ensure_fromlist(mod, all, buf, buflen, 1);
-				Py_DECREF(all);
-				if (!ret)
-					return 0;
-			}
-			continue;
-		}
-		hasit = PyObject_HasAttr(mod, item);
-		if (!hasit) {
-			char *subname = PyString_AS_STRING(item);
-			PyObject *submod;
-			char *p;
-			if (buflen + strlen(subname) >= MAXPATHLEN) {
-				PyErr_SetString(PyExc_ValueError,
-						"Module name too long");
-				Py_DECREF(item);
-				return 0;
-			}
-			p = buf + buflen;
-			*p++ = '.';
-			strcpy(p, subname);
-			submod = import_submodule(mod, subname, buf);
-			Py_XDECREF(submod);
-			if (submod == NULL) {
-				Py_DECREF(item);
-				return 0;
-			}
-		}
-		Py_DECREF(item);
-	}
-
-	/* NOTREACHED */
+                int recursive)
+{
+    int i;
+
+    if (!PyObject_HasAttrString(mod, "__path__"))
+        return 1;
+
+    for (i = 0; ; i++) {
+        PyObject *item = PySequence_GetItem(fromlist, i);
+        int hasit;
+        if (item == NULL) {
+            if (PyErr_ExceptionMatches(PyExc_IndexError)) {
+                PyErr_Clear();
+                return 1;
+            }
+            return 0;
+        }
+        if (!PyString_Check(item)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "Item in ``from list'' not a string");
+            Py_DECREF(item);
+            return 0;
+        }
+        if (PyString_AS_STRING(item)[0] == '*') {
+            PyObject *all;
+            Py_DECREF(item);
+            /* See if the package defines __all__ */
+            if (recursive)
+                continue; /* Avoid endless recursion */
+            all = PyObject_GetAttrString(mod, "__all__");
+            if (all == NULL)
+                PyErr_Clear();
+            else {
+                int ret = ensure_fromlist(mod, all, buf, buflen, 1);
+                Py_DECREF(all);
+                if (!ret)
+                    return 0;
+            }
+            continue;
+        }
+        hasit = PyObject_HasAttr(mod, item);
+        if (!hasit) {
+            char *subname = PyString_AS_STRING(item);
+            PyObject *submod;
+            char *p;
+            if (buflen + strlen(subname) >= MAXPATHLEN) {
+                PyErr_SetString(PyExc_ValueError,
+                                "Module name too long");
+                Py_DECREF(item);
+                return 0;
+            }
+            p = buf + buflen;
+            *p++ = '.';
+            strcpy(p, subname);
+            submod = import_submodule(mod, subname, buf);
+            Py_XDECREF(submod);
+            if (submod == NULL) {
+                Py_DECREF(item);
+                return 0;
+            }
+        }
+        Py_DECREF(item);
+    }
+
+    /* NOTREACHED */
 }
 
 static int
 add_submodule(PyObject *mod, PyObject *submod, char *fullname, char *subname,
-	      PyObject *modules)
-{
-	if (mod == Py_None)
-		return 1;
-	/* Irrespective of the success of this load, make a
-	   reference to it in the parent package module.  A copy gets
-	   saved in the modules dictionary under the full name, so get a
-	   reference from there, if need be.  (The exception is when the
-	   load failed with a SyntaxError -- then there's no trace in
-	   sys.modules.  In that case, of course, do nothing extra.) */
-	if (submod == NULL) {
-		submod = PyDict_GetItemString(modules, fullname);
-		if (submod == NULL)
-			return 1;
-	}
-	if (PyModule_Check(mod)) {
-		/* We can't use setattr here since it can give a
-		 * spurious warning if the submodule name shadows a
-		 * builtin name */
-		PyObject *dict = PyModule_GetDict(mod);
-		if (!dict)
-			return 0;
-		if (PyDict_SetItemString(dict, subname, submod) < 0)
-			return 0;
-	}
-	else {
-		if (PyObject_SetAttrString(mod, subname, submod) < 0)
-			return 0;
-	}
-	return 1;
+              PyObject *modules)
+{
+    if (mod == Py_None)
+        return 1;
+    /* Irrespective of the success of this load, make a
+       reference to it in the parent package module.  A copy gets
+       saved in the modules dictionary under the full name, so get a
+       reference from there, if need be.  (The exception is when the
+       load failed with a SyntaxError -- then there's no trace in
+       sys.modules.  In that case, of course, do nothing extra.) */
+    if (submod == NULL) {
+        submod = PyDict_GetItemString(modules, fullname);
+        if (submod == NULL)
+            return 1;
+    }
+    if (PyModule_Check(mod)) {
+        /* We can't use setattr here since it can give a
+         * spurious warning if the submodule name shadows a
+         * builtin name */
+        PyObject *dict = PyModule_GetDict(mod);
+        if (!dict)
+            return 0;
+        if (PyDict_SetItemString(dict, subname, submod) < 0)
+            return 0;
+    }
+    else {
+        if (PyObject_SetAttrString(mod, subname, submod) < 0)
+            return 0;
+    }
+    return 1;
 }
 
 static PyObject *
 import_submodule(PyObject *mod, char *subname, char *fullname)
 {
-	PyObject *modules = PyImport_GetModuleDict();
-	PyObject *m = NULL;
-
-	/* Require:
-	   if mod == None: subname == fullname
-	   else: mod.__name__ + "." + subname == fullname
-	*/
-
-	if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
-		Py_INCREF(m);
-	}
-	else {
-		PyObject *path, *loader = NULL;
-		char buf[MAXPATHLEN+1];
-		struct filedescr *fdp;
-		FILE *fp = NULL;
-
-		if (mod == Py_None)
-			path = NULL;
-		else {
-			path = PyObject_GetAttrString(mod, "__path__");
-			if (path == NULL) {
-				PyErr_Clear();
-				Py_INCREF(Py_None);
-				return Py_None;
-			}
-		}
-
-		buf[0] = '\0';
-		fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
-				  &fp, &loader);
-		Py_XDECREF(path);
-		if (fdp == NULL) {
-			if (!PyErr_ExceptionMatches(PyExc_ImportError))
-				return NULL;
-			PyErr_Clear();
-			Py_INCREF(Py_None);
-			return Py_None;
-		}
-		m = load_module(fullname, fp, buf, fdp->type, loader);
-		Py_XDECREF(loader);
-		if (fp)
-			fclose(fp);
-		if (!add_submodule(mod, m, fullname, subname, modules)) {
-			Py_XDECREF(m);
-			m = NULL;
-		}
-	}
-
-	return m;
+    PyObject *modules = PyImport_GetModuleDict();
+    PyObject *m = NULL;
+
+    /* Require:
+       if mod == None: subname == fullname
+       else: mod.__name__ + "." + subname == fullname
+    */
+
+    if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
+        Py_INCREF(m);
+    }
+    else {
+        PyObject *path, *loader = NULL;
+        char buf[MAXPATHLEN+1];
+        struct filedescr *fdp;
+        FILE *fp = NULL;
+
+        if (mod == Py_None)
+            path = NULL;
+        else {
+            path = PyObject_GetAttrString(mod, "__path__");
+            if (path == NULL) {
+                PyErr_Clear();
+                Py_INCREF(Py_None);
+                return Py_None;
+            }
+        }
+
+        buf[0] = '\0';
+        fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
+                          &fp, &loader);
+        Py_XDECREF(path);
+        if (fdp == NULL) {
+            if (!PyErr_ExceptionMatches(PyExc_ImportError))
+                return NULL;
+            PyErr_Clear();
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+        m = load_module(fullname, fp, buf, fdp->type, loader);
+        Py_XDECREF(loader);
+        if (fp)
+            fclose(fp);
+        if (!add_submodule(mod, m, fullname, subname, modules)) {
+            Py_XDECREF(m);
+            m = NULL;
+        }
+    }
+
+    return m;
 }
 
 
@@ -2612,96 +2612,96 @@ import_submodule(PyObject *mod, char *subname, char *fullname)
 PyObject *
 PyImport_ReloadModule(PyObject *m)
 {
-	PyInterpreterState *interp = PyThreadState_Get()->interp;
-	PyObject *modules_reloading = interp->modules_reloading;
-	PyObject *modules = PyImport_GetModuleDict();
-	PyObject *path = NULL, *loader = NULL, *existing_m = NULL;
-	char *name, *subname;
-	char buf[MAXPATHLEN+1];
-	struct filedescr *fdp;
-	FILE *fp = NULL;
-	PyObject *newm;
-
-	if (modules_reloading == NULL) {
-		Py_FatalError("PyImport_ReloadModule: "
-			      "no modules_reloading dictionary!");
-		return NULL;
-	}
-
-	if (m == NULL || !PyModule_Check(m)) {
-		PyErr_SetString(PyExc_TypeError,
-				"reload() argument must be module");
-		return NULL;
-	}
-	name = PyModule_GetName(m);
-	if (name == NULL)
-		return NULL;
-	if (m != PyDict_GetItemString(modules, name)) {
-		PyErr_Format(PyExc_ImportError,
-			     "reload(): module %.200s not in sys.modules",
-			     name);
-		return NULL;
-	}
-	existing_m = PyDict_GetItemString(modules_reloading, name);
-	if (existing_m != NULL) {
-		/* Due to a recursive reload, this module is already
-		   being reloaded. */
-		Py_INCREF(existing_m);
-		return existing_m;
- 	}
- 	if (PyDict_SetItemString(modules_reloading, name, m) < 0)
-		return NULL;
-
-	subname = strrchr(name, '.');
-	if (subname == NULL)
-		subname = name;
-	else {
-		PyObject *parentname, *parent;
-		parentname = PyString_FromStringAndSize(name, (subname-name));
-		if (parentname == NULL) {
-			imp_modules_reloading_clear();
-			return NULL;
-        	}
-		parent = PyDict_GetItem(modules, parentname);
-		if (parent == NULL) {
-			PyErr_Format(PyExc_ImportError,
-			    "reload(): parent %.200s not in sys.modules",
-			    PyString_AS_STRING(parentname));
-			Py_DECREF(parentname);
-			imp_modules_reloading_clear();
-			return NULL;
-		}
-		Py_DECREF(parentname);
-		subname++;
-		path = PyObject_GetAttrString(parent, "__path__");
-		if (path == NULL)
-			PyErr_Clear();
-	}
-	buf[0] = '\0';
-	fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader);
-	Py_XDECREF(path);
-
-	if (fdp == NULL) {
-		Py_XDECREF(loader);
-		imp_modules_reloading_clear();
-		return NULL;
-	}
-
-	newm = load_module(name, fp, buf, fdp->type, loader);
-	Py_XDECREF(loader);
-
-	if (fp)
-		fclose(fp);
-	if (newm == NULL) {
-		/* load_module probably removed name from modules because of
-		 * the error.  Put back the original module object.  We're
-		 * going to return NULL in this case regardless of whether
-		 * replacing name succeeds, so the return value is ignored.
-		 */
-		PyDict_SetItemString(modules, name, m);
-	}
-	imp_modules_reloading_clear();
-	return newm;
+    PyInterpreterState *interp = PyThreadState_Get()->interp;
+    PyObject *modules_reloading = interp->modules_reloading;
+    PyObject *modules = PyImport_GetModuleDict();
+    PyObject *path = NULL, *loader = NULL, *existing_m = NULL;
+    char *name, *subname;
+    char buf[MAXPATHLEN+1];
+    struct filedescr *fdp;
+    FILE *fp = NULL;
+    PyObject *newm;
+
+    if (modules_reloading == NULL) {
+        Py_FatalError("PyImport_ReloadModule: "
+                      "no modules_reloading dictionary!");
+        return NULL;
+    }
+
+    if (m == NULL || !PyModule_Check(m)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "reload() argument must be module");
+        return NULL;
+    }
+    name = PyModule_GetName(m);
+    if (name == NULL)
+        return NULL;
+    if (m != PyDict_GetItemString(modules, name)) {
+        PyErr_Format(PyExc_ImportError,
+                     "reload(): module %.200s not in sys.modules",
+                     name);
+        return NULL;
+    }
+    existing_m = PyDict_GetItemString(modules_reloading, name);
+    if (existing_m != NULL) {
+        /* Due to a recursive reload, this module is already
+           being reloaded. */
+        Py_INCREF(existing_m);
+        return existing_m;
+    }
+    if (PyDict_SetItemString(modules_reloading, name, m) < 0)
+        return NULL;
+
+    subname = strrchr(name, '.');
+    if (subname == NULL)
+        subname = name;
+    else {
+        PyObject *parentname, *parent;
+        parentname = PyString_FromStringAndSize(name, (subname-name));
+        if (parentname == NULL) {
+            imp_modules_reloading_clear();
+            return NULL;
+        }
+        parent = PyDict_GetItem(modules, parentname);
+        if (parent == NULL) {
+            PyErr_Format(PyExc_ImportError,
+                "reload(): parent %.200s not in sys.modules",
+                PyString_AS_STRING(parentname));
+            Py_DECREF(parentname);
+            imp_modules_reloading_clear();
+            return NULL;
+        }
+        Py_DECREF(parentname);
+        subname++;
+        path = PyObject_GetAttrString(parent, "__path__");
+        if (path == NULL)
+            PyErr_Clear();
+    }
+    buf[0] = '\0';
+    fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader);
+    Py_XDECREF(path);
+
+    if (fdp == NULL) {
+        Py_XDECREF(loader);
+        imp_modules_reloading_clear();
+        return NULL;
+    }
+
+    newm = load_module(name, fp, buf, fdp->type, loader);
+    Py_XDECREF(loader);
+
+    if (fp)
+        fclose(fp);
+    if (newm == NULL) {
+        /* load_module probably removed name from modules because of
+         * the error.  Put back the original module object.  We're
+         * going to return NULL in this case regardless of whether
+         * replacing name succeeds, so the return value is ignored.
+         */
+        PyDict_SetItemString(modules, name, m);
+    }
+    imp_modules_reloading_clear();
+    return newm;
 }
 
 
@@ -2717,68 +2717,68 @@ PyImport_ReloadModule(PyObject *m)
 PyObject *
 PyImport_Import(PyObject *module_name)
 {
-	static PyObject *silly_list = NULL;
-	static PyObject *builtins_str = NULL;
-	static PyObject *import_str = NULL;
-	PyObject *globals = NULL;
-	PyObject *import = NULL;
-	PyObject *builtins = NULL;
-	PyObject *r = NULL;
-
-	/* Initialize constant string objects */
-	if (silly_list == NULL) {
-		import_str = PyString_InternFromString("__import__");
-		if (import_str == NULL)
-			return NULL;
-		builtins_str = PyString_InternFromString("__builtins__");
-		if (builtins_str == NULL)
-			return NULL;
-		silly_list = Py_BuildValue("[s]", "__doc__");
-		if (silly_list == NULL)
-			return NULL;
-	}
-
-	/* Get the builtins from current globals */
-	globals = PyEval_GetGlobals();
-	if (globals != NULL) {
-	        Py_INCREF(globals);
-		builtins = PyObject_GetItem(globals, builtins_str);
-		if (builtins == NULL)
-			goto err;
-	}
-	else {
-		/* No globals -- use standard builtins, and fake globals */
-		builtins = PyImport_ImportModuleLevel("__builtin__",
-						      NULL, NULL, NULL, 0);
-		if (builtins == NULL)
-			return NULL;
-		globals = Py_BuildValue("{OO}", builtins_str, builtins);
-		if (globals == NULL)
-			goto err;
-	}
-
-	/* Get the __import__ function from the builtins */
-	if (PyDict_Check(builtins)) {
-		import = PyObject_GetItem(builtins, import_str);
-		if (import == NULL)
-			PyErr_SetObject(PyExc_KeyError, import_str);
-	}
-	else
-		import = PyObject_GetAttr(builtins, import_str);
-	if (import == NULL)
-		goto err;
-
-	/* Call the __import__ function with the proper argument list
-	 * Always use absolute import here. */
-	r = PyObject_CallFunction(import, "OOOOi", module_name, globals,
-				  globals, silly_list, 0, NULL);
+    static PyObject *silly_list = NULL;
+    static PyObject *builtins_str = NULL;
+    static PyObject *import_str = NULL;
+    PyObject *globals = NULL;
+    PyObject *import = NULL;
+    PyObject *builtins = NULL;
+    PyObject *r = NULL;
+
+    /* Initialize constant string objects */
+    if (silly_list == NULL) {
+        import_str = PyString_InternFromString("__import__");
+        if (import_str == NULL)
+            return NULL;
+        builtins_str = PyString_InternFromString("__builtins__");
+        if (builtins_str == NULL)
+            return NULL;
+        silly_list = Py_BuildValue("[s]", "__doc__");
+        if (silly_list == NULL)
+            return NULL;
+    }
+
+    /* Get the builtins from current globals */
+    globals = PyEval_GetGlobals();
+    if (globals != NULL) {
+        Py_INCREF(globals);
+        builtins = PyObject_GetItem(globals, builtins_str);
+        if (builtins == NULL)
+            goto err;
+    }
+    else {
+        /* No globals -- use standard builtins, and fake globals */
+        builtins = PyImport_ImportModuleLevel("__builtin__",
+                                              NULL, NULL, NULL, 0);
+        if (builtins == NULL)
+            return NULL;
+        globals = Py_BuildValue("{OO}", builtins_str, builtins);
+        if (globals == NULL)
+            goto err;
+    }
+
+    /* Get the __import__ function from the builtins */
+    if (PyDict_Check(builtins)) {
+        import = PyObject_GetItem(builtins, import_str);
+        if (import == NULL)
+            PyErr_SetObject(PyExc_KeyError, import_str);
+    }
+    else
+        import = PyObject_GetAttr(builtins, import_str);
+    if (import == NULL)
+        goto err;
+
+    /* Call the __import__ function with the proper argument list
+     * Always use absolute import here. */
+    r = PyObject_CallFunction(import, "OOOOi", module_name, globals,
+                              globals, silly_list, 0, NULL);
 
   err:
-	Py_XDECREF(globals);
-	Py_XDECREF(builtins);
-	Py_XDECREF(import);
+    Py_XDECREF(globals);
+    Py_XDECREF(builtins);
+    Py_XDECREF(import);
 
-	return r;
+    return r;
 }
 
 
@@ -2789,192 +2789,192 @@ PyImport_Import(PyObject *module_name)
 static PyObject *
 imp_get_magic(PyObject *self, PyObject *noargs)
 {
-	char buf[4];
+    char buf[4];
 
-	buf[0] = (char) ((pyc_magic >>  0) & 0xff);
-	buf[1] = (char) ((pyc_magic >>  8) & 0xff);
-	buf[2] = (char) ((pyc_magic >> 16) & 0xff);
-	buf[3] = (char) ((pyc_magic >> 24) & 0xff);
+    buf[0] = (char) ((pyc_magic >>  0) & 0xff);
+    buf[1] = (char) ((pyc_magic >>  8) & 0xff);
+    buf[2] = (char) ((pyc_magic >> 16) & 0xff);
+    buf[3] = (char) ((pyc_magic >> 24) & 0xff);
 
-	return PyString_FromStringAndSize(buf, 4);
+    return PyString_FromStringAndSize(buf, 4);
 }
 
 static PyObject *
 imp_get_suffixes(PyObject *self, PyObject *noargs)
 {
-	PyObject *list;
-	struct filedescr *fdp;
-
-	list = PyList_New(0);
-	if (list == NULL)
-		return NULL;
-	for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
-		PyObject *item = Py_BuildValue("ssi",
-				       fdp->suffix, fdp->mode, fdp->type);
-		if (item == NULL) {
-			Py_DECREF(list);
-			return NULL;
-		}
-		if (PyList_Append(list, item) < 0) {
-			Py_DECREF(list);
-			Py_DECREF(item);
-			return NULL;
-		}
-		Py_DECREF(item);
-	}
-	return list;
+    PyObject *list;
+    struct filedescr *fdp;
+
+    list = PyList_New(0);
+    if (list == NULL)
+        return NULL;
+    for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
+        PyObject *item = Py_BuildValue("ssi",
+                               fdp->suffix, fdp->mode, fdp->type);
+        if (item == NULL) {
+            Py_DECREF(list);
+            return NULL;
+        }
+        if (PyList_Append(list, item) < 0) {
+            Py_DECREF(list);
+            Py_DECREF(item);
+            return NULL;
+        }
+        Py_DECREF(item);
+    }
+    return list;
 }
 
 static PyObject *
 call_find_module(char *name, PyObject *path)
 {
-	extern int fclose(FILE *);
-	PyObject *fob, *ret;
-	struct filedescr *fdp;
-	char pathname[MAXPATHLEN+1];
-	FILE *fp = NULL;
-
-	pathname[0] = '\0';
-	if (path == Py_None)
-		path = NULL;
-	fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL);
-	if (fdp == NULL)
-		return NULL;
-	if (fp != NULL) {
-		fob = PyFile_FromFile(fp, pathname, fdp->mode, fclose);
-		if (fob == NULL) {
-			fclose(fp);
-			return NULL;
-		}
-	}
-	else {
-		fob = Py_None;
-		Py_INCREF(fob);
-	}
-	ret = Py_BuildValue("Os(ssi)",
-		      fob, pathname, fdp->suffix, fdp->mode, fdp->type);
-	Py_DECREF(fob);
-	return ret;
+    extern int fclose(FILE *);
+    PyObject *fob, *ret;
+    struct filedescr *fdp;
+    char pathname[MAXPATHLEN+1];
+    FILE *fp = NULL;
+
+    pathname[0] = '\0';
+    if (path == Py_None)
+        path = NULL;
+    fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL);
+    if (fdp == NULL)
+        return NULL;
+    if (fp != NULL) {
+        fob = PyFile_FromFile(fp, pathname, fdp->mode, fclose);
+        if (fob == NULL) {
+            fclose(fp);
+            return NULL;
+        }
+    }
+    else {
+        fob = Py_None;
+        Py_INCREF(fob);
+    }
+    ret = Py_BuildValue("Os(ssi)",
+                  fob, pathname, fdp->suffix, fdp->mode, fdp->type);
+    Py_DECREF(fob);
+    return ret;
 }
 
 static PyObject *
 imp_find_module(PyObject *self, PyObject *args)
 {
-	char *name;
-	PyObject *path = NULL;
-	if (!PyArg_ParseTuple(args, "s|O:find_module", &name, &path))
-		return NULL;
-	return call_find_module(name, path);
+    char *name;
+    PyObject *path = NULL;
+    if (!PyArg_ParseTuple(args, "s|O:find_module", &name, &path))
+        return NULL;
+    return call_find_module(name, path);
 }
 
 static PyObject *
 imp_init_builtin(PyObject *self, PyObject *args)
 {
-	char *name;
-	int ret;
-	PyObject *m;
-	if (!PyArg_ParseTuple(args, "s:init_builtin", &name))
-		return NULL;
-	ret = init_builtin(name);
-	if (ret < 0)
-		return NULL;
-	if (ret == 0) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	m = PyImport_AddModule(name);
-	Py_XINCREF(m);
-	return m;
+    char *name;
+    int ret;
+    PyObject *m;
+    if (!PyArg_ParseTuple(args, "s:init_builtin", &name))
+        return NULL;
+    ret = init_builtin(name);
+    if (ret < 0)
+        return NULL;
+    if (ret == 0) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    m = PyImport_AddModule(name);
+    Py_XINCREF(m);
+    return m;
 }
 
 static PyObject *
 imp_init_frozen(PyObject *self, PyObject *args)
 {
-	char *name;
-	int ret;
-	PyObject *m;
-	if (!PyArg_ParseTuple(args, "s:init_frozen", &name))
-		return NULL;
-	ret = PyImport_ImportFrozenModule(name);
-	if (ret < 0)
-		return NULL;
-	if (ret == 0) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	m = PyImport_AddModule(name);
-	Py_XINCREF(m);
-	return m;
+    char *name;
+    int ret;
+    PyObject *m;
+    if (!PyArg_ParseTuple(args, "s:init_frozen", &name))
+        return NULL;
+    ret = PyImport_ImportFrozenModule(name);
+    if (ret < 0)
+        return NULL;
+    if (ret == 0) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    m = PyImport_AddModule(name);
+    Py_XINCREF(m);
+    return m;
 }
 
 static PyObject *
 imp_get_frozen_object(PyObject *self, PyObject *args)
 {
-	char *name;
+    char *name;
 
-	if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name))
-		return NULL;
-	return get_frozen_object(name);
+    if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name))
+        return NULL;
+    return get_frozen_object(name);
 }
 
 static PyObject *
 imp_is_builtin(PyObject *self, PyObject *args)
 {
-	char *name;
-	if (!PyArg_ParseTuple(args, "s:is_builtin", &name))
-		return NULL;
-	return PyInt_FromLong(is_builtin(name));
+    char *name;
+    if (!PyArg_ParseTuple(args, "s:is_builtin", &name))
+        return NULL;
+    return PyInt_FromLong(is_builtin(name));
 }
 
 static PyObject *
 imp_is_frozen(PyObject *self, PyObject *args)
 {
-	char *name;
-	struct _frozen *p;
-	if (!PyArg_ParseTuple(args, "s:is_frozen", &name))
-		return NULL;
-	p = find_frozen(name);
-	return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
+    char *name;
+    struct _frozen *p;
+    if (!PyArg_ParseTuple(args, "s:is_frozen", &name))
+        return NULL;
+    p = find_frozen(name);
+    return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
 }
 
 static FILE *
 get_file(char *pathname, PyObject *fob, char *mode)
 {
-	FILE *fp;
-	if (fob == NULL) {
-		if (mode[0] == 'U')
-			mode = "r" PY_STDIOTEXTMODE;
-		fp = fopen(pathname, mode);
-		if (fp == NULL)
-			PyErr_SetFromErrno(PyExc_IOError);
-	}
-	else {
-		fp = PyFile_AsFile(fob);
-		if (fp == NULL)
-			PyErr_SetString(PyExc_ValueError,
-					"bad/closed file object");
-	}
-	return fp;
+    FILE *fp;
+    if (fob == NULL) {
+        if (mode[0] == 'U')
+            mode = "r" PY_STDIOTEXTMODE;
+        fp = fopen(pathname, mode);
+        if (fp == NULL)
+            PyErr_SetFromErrno(PyExc_IOError);
+    }
+    else {
+        fp = PyFile_AsFile(fob);
+        if (fp == NULL)
+            PyErr_SetString(PyExc_ValueError,
+                            "bad/closed file object");
+    }
+    return fp;
 }
 
 static PyObject *
 imp_load_compiled(PyObject *self, PyObject *args)
 {
-	char *name;
-	char *pathname;
-	PyObject *fob = NULL;
-	PyObject *m;
-	FILE *fp;
-	if (!PyArg_ParseTuple(args, "ss|O!:load_compiled", &name, &pathname,
-			      &PyFile_Type, &fob))
-		return NULL;
-	fp = get_file(pathname, fob, "rb");
-	if (fp == NULL)
-		return NULL;
-	m = load_compiled_module(name, pathname, fp);
-	if (fob == NULL)
-		fclose(fp);
-	return m;
+    char *name;
+    char *pathname;
+    PyObject *fob = NULL;
+    PyObject *m;
+    FILE *fp;
+    if (!PyArg_ParseTuple(args, "ss|O!:load_compiled", &name, &pathname,
+                          &PyFile_Type, &fob))
+        return NULL;
+    fp = get_file(pathname, fob, "rb");
+    if (fp == NULL)
+        return NULL;
+    m = load_compiled_module(name, pathname, fp);
+    if (fob == NULL)
+        fclose(fp);
+    return m;
 }
 
 #ifdef HAVE_DYNAMIC_LOADING
@@ -2982,21 +2982,21 @@ imp_load_compiled(PyObject *self, PyObject *args)
 static PyObject *
 imp_load_dynamic(PyObject *self, PyObject *args)
 {
-	char *name;
-	char *pathname;
-	PyObject *fob = NULL;
-	PyObject *m;
-	FILE *fp = NULL;
-	if (!PyArg_ParseTuple(args, "ss|O!:load_dynamic", &name, &pathname,
-			      &PyFile_Type, &fob))
-		return NULL;
-	if (fob) {
-		fp = get_file(pathname, fob, "r");
-		if (fp == NULL)
-			return NULL;
-	}
-	m = _PyImport_LoadDynamicModule(name, pathname, fp);
-	return m;
+    char *name;
+    char *pathname;
+    PyObject *fob = NULL;
+    PyObject *m;
+    FILE *fp = NULL;
+    if (!PyArg_ParseTuple(args, "ss|O!:load_dynamic", &name, &pathname,
+                          &PyFile_Type, &fob))
+        return NULL;
+    if (fob) {
+        fp = get_file(pathname, fob, "r");
+        if (fp == NULL)
+            return NULL;
+    }
+    m = _PyImport_LoadDynamicModule(name, pathname, fp);
+    return m;
 }
 
 #endif /* HAVE_DYNAMIC_LOADING */
@@ -3004,87 +3004,87 @@ imp_load_dynamic(PyObject *self, PyObject *args)
 static PyObject *
 imp_load_source(PyObject *self, PyObject *args)
 {
-	char *name;
-	char *pathname;
-	PyObject *fob = NULL;
-	PyObject *m;
-	FILE *fp;
-	if (!PyArg_ParseTuple(args, "ss|O!:load_source", &name, &pathname,
-			      &PyFile_Type, &fob))
-		return NULL;
-	fp = get_file(pathname, fob, "r");
-	if (fp == NULL)
-		return NULL;
-	m = load_source_module(name, pathname, fp);
-	if (fob == NULL)
-		fclose(fp);
-	return m;
+    char *name;
+    char *pathname;
+    PyObject *fob = NULL;
+    PyObject *m;
+    FILE *fp;
+    if (!PyArg_ParseTuple(args, "ss|O!:load_source", &name, &pathname,
+                          &PyFile_Type, &fob))
+        return NULL;
+    fp = get_file(pathname, fob, "r");
+    if (fp == NULL)
+        return NULL;
+    m = load_source_module(name, pathname, fp);
+    if (fob == NULL)
+        fclose(fp);
+    return m;
 }
 
 static PyObject *
 imp_load_module(PyObject *self, PyObject *args)
 {
-	char *name;
-	PyObject *fob;
-	char *pathname;
-	char *suffix; /* Unused */
-	char *mode;
-	int type;
-	FILE *fp;
-
-	if (!PyArg_ParseTuple(args, "sOs(ssi):load_module",
-			      &name, &fob, &pathname,
-			      &suffix, &mode, &type))
-		return NULL;
-	if (*mode) {
-		/* Mode must start with 'r' or 'U' and must not contain '+'.
-		   Implicit in this test is the assumption that the mode
-		   may contain other modifiers like 'b' or 't'. */
-
-		if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) {
-			PyErr_Format(PyExc_ValueError,
-				     "invalid file open mode %.200s", mode);
-			return NULL;
-		}
-	}
-	if (fob == Py_None)
-		fp = NULL;
-	else {
-		if (!PyFile_Check(fob)) {
-			PyErr_SetString(PyExc_ValueError,
-				"load_module arg#2 should be a file or None");
-			return NULL;
-		}
-		fp = get_file(pathname, fob, mode);
-		if (fp == NULL)
-			return NULL;
-	}
-	return load_module(name, fp, pathname, type, NULL);
+    char *name;
+    PyObject *fob;
+    char *pathname;
+    char *suffix; /* Unused */
+    char *mode;
+    int type;
+    FILE *fp;
+
+    if (!PyArg_ParseTuple(args, "sOs(ssi):load_module",
+                          &name, &fob, &pathname,
+                          &suffix, &mode, &type))
+        return NULL;
+    if (*mode) {
+        /* Mode must start with 'r' or 'U' and must not contain '+'.
+           Implicit in this test is the assumption that the mode
+           may contain other modifiers like 'b' or 't'. */
+
+        if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) {
+            PyErr_Format(PyExc_ValueError,
+                         "invalid file open mode %.200s", mode);
+            return NULL;
+        }
+    }
+    if (fob == Py_None)
+        fp = NULL;
+    else {
+        if (!PyFile_Check(fob)) {
+            PyErr_SetString(PyExc_ValueError,
+                "load_module arg#2 should be a file or None");
+            return NULL;
+        }
+        fp = get_file(pathname, fob, mode);
+        if (fp == NULL)
+            return NULL;
+    }
+    return load_module(name, fp, pathname, type, NULL);
 }
 
 static PyObject *
 imp_load_package(PyObject *self, PyObject *args)
 {
-	char *name;
-	char *pathname;
-	if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname))
-		return NULL;
-	return load_package(name, pathname);
+    char *name;
+    char *pathname;
+    if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname))
+        return NULL;
+    return load_package(name, pathname);
 }
 
 static PyObject *
 imp_new_module(PyObject *self, PyObject *args)
 {
-	char *name;
-	if (!PyArg_ParseTuple(args, "s:new_module", &name))
-		return NULL;
-	return PyModule_New(name);
+    char *name;
+    if (!PyArg_ParseTuple(args, "s:new_module", &name))
+        return NULL;
+    return PyModule_New(name);
 }
 
 static PyObject *
 imp_reload(PyObject *self, PyObject *v)
 {
-	return PyImport_ReloadModule(v);
+    return PyImport_ReloadModule(v);
 }
 
 
@@ -3143,40 +3143,40 @@ Release the interpreter's import lock.\n\
 On platforms without threads, this function does nothing.");
 
 static PyMethodDef imp_methods[] = {
-	{"reload",	 imp_reload,	   METH_O,	 doc_reload},
-	{"find_module",	 imp_find_module,  METH_VARARGS, doc_find_module},
-	{"get_magic",	 imp_get_magic,	   METH_NOARGS,  doc_get_magic},
-	{"get_suffixes", imp_get_suffixes, METH_NOARGS,  doc_get_suffixes},
-	{"load_module",	 imp_load_module,  METH_VARARGS, doc_load_module},
-	{"new_module",	 imp_new_module,   METH_VARARGS, doc_new_module},
-	{"lock_held",	 imp_lock_held,	   METH_NOARGS,  doc_lock_held},
-	{"acquire_lock", imp_acquire_lock, METH_NOARGS,  doc_acquire_lock},
-	{"release_lock", imp_release_lock, METH_NOARGS,  doc_release_lock},
-	/* The rest are obsolete */
-	{"get_frozen_object",	imp_get_frozen_object,	METH_VARARGS},
-	{"init_builtin",	imp_init_builtin,	METH_VARARGS},
-	{"init_frozen",		imp_init_frozen,	METH_VARARGS},
-	{"is_builtin",		imp_is_builtin,		METH_VARARGS},
-	{"is_frozen",		imp_is_frozen,		METH_VARARGS},
-	{"load_compiled",	imp_load_compiled,	METH_VARARGS},
+    {"reload",           imp_reload,       METH_O,       doc_reload},
+    {"find_module",      imp_find_module,  METH_VARARGS, doc_find_module},
+    {"get_magic",        imp_get_magic,    METH_NOARGS,  doc_get_magic},
+    {"get_suffixes", imp_get_suffixes, METH_NOARGS,  doc_get_suffixes},
+    {"load_module",      imp_load_module,  METH_VARARGS, doc_load_module},
+    {"new_module",       imp_new_module,   METH_VARARGS, doc_new_module},
+    {"lock_held",        imp_lock_held,    METH_NOARGS,  doc_lock_held},
+    {"acquire_lock", imp_acquire_lock, METH_NOARGS,  doc_acquire_lock},
+    {"release_lock", imp_release_lock, METH_NOARGS,  doc_release_lock},
+    /* The rest are obsolete */
+    {"get_frozen_object",       imp_get_frozen_object,  METH_VARARGS},
+    {"init_builtin",            imp_init_builtin,       METH_VARARGS},
+    {"init_frozen",             imp_init_frozen,        METH_VARARGS},
+    {"is_builtin",              imp_is_builtin,         METH_VARARGS},
+    {"is_frozen",               imp_is_frozen,          METH_VARARGS},
+    {"load_compiled",           imp_load_compiled,      METH_VARARGS},
 #ifdef HAVE_DYNAMIC_LOADING
-	{"load_dynamic",	imp_load_dynamic,	METH_VARARGS},
+    {"load_dynamic",            imp_load_dynamic,       METH_VARARGS},
 #endif
-	{"load_package",	imp_load_package,	METH_VARARGS},
-	{"load_source",		imp_load_source,	METH_VARARGS},
-	{NULL,			NULL}		/* sentinel */
+    {"load_package",            imp_load_package,       METH_VARARGS},
+    {"load_source",             imp_load_source,        METH_VARARGS},
+    {NULL,                      NULL}           /* sentinel */
 };
 
 static int
 setint(PyObject *d, char *name, int value)
 {
-	PyObject *v;
-	int err;
+    PyObject *v;
+    int err;
 
-	v = PyInt_FromLong((long)value);
-	err = PyDict_SetItemString(d, name, v);
-	Py_XDECREF(v);
-	return err;
+    v = PyInt_FromLong((long)value);
+    err = PyDict_SetItemString(d, name, v);
+    Py_XDECREF(v);
+    return err;
 }
 
 typedef struct {
@@ -3186,155 +3186,155 @@ typedef struct {
 static int
 NullImporter_init(NullImporter *self, PyObject *args, PyObject *kwds)
 {
-	char *path;
-	Py_ssize_t pathlen;
+    char *path;
+    Py_ssize_t pathlen;
 
-	if (!_PyArg_NoKeywords("NullImporter()", kwds))
-		return -1;
+    if (!_PyArg_NoKeywords("NullImporter()", kwds))
+        return -1;
 
-	if (!PyArg_ParseTuple(args, "s:NullImporter",
-			      &path))
-		return -1;
+    if (!PyArg_ParseTuple(args, "s:NullImporter",
+                          &path))
+        return -1;
 
-	pathlen = strlen(path);
-	if (pathlen == 0) {
-		PyErr_SetString(PyExc_ImportError, "empty pathname");
-		return -1;
-	} else {
+    pathlen = strlen(path);
+    if (pathlen == 0) {
+        PyErr_SetString(PyExc_ImportError, "empty pathname");
+        return -1;
+    } else {
 #ifndef RISCOS
 #ifndef MS_WINDOWS
-		struct stat statbuf;
-		int rv;
-
-		rv = stat(path, &statbuf);
-		if (rv == 0) {
-			/* it exists */
-			if (S_ISDIR(statbuf.st_mode)) {
-				/* it's a directory */
-				PyErr_SetString(PyExc_ImportError,
-						"existing directory");
-				return -1;
-			}
-		}
+        struct stat statbuf;
+        int rv;
+
+        rv = stat(path, &statbuf);
+        if (rv == 0) {
+            /* it exists */
+            if (S_ISDIR(statbuf.st_mode)) {
+                /* it's a directory */
+                PyErr_SetString(PyExc_ImportError,
+                                "existing directory");
+                return -1;
+            }
+        }
 #else /* MS_WINDOWS */
-		DWORD rv;
-		/* see issue1293 and issue3677:
-		 * stat() on Windows doesn't recognise paths like
-		 * "e:\\shared\\" and "\\\\whiterab-c2znlh\\shared" as dirs.
-		 */
-		rv = GetFileAttributesA(path);
-		if (rv != INVALID_FILE_ATTRIBUTES) {
-			/* it exists */
-			if (rv & FILE_ATTRIBUTE_DIRECTORY) {
-				/* it's a directory */
-				PyErr_SetString(PyExc_ImportError,
-						"existing directory");
-				return -1;
-			}
-		}
+        DWORD rv;
+        /* see issue1293 and issue3677:
+         * stat() on Windows doesn't recognise paths like
+         * "e:\\shared\\" and "\\\\whiterab-c2znlh\\shared" as dirs.
+         */
+        rv = GetFileAttributesA(path);
+        if (rv != INVALID_FILE_ATTRIBUTES) {
+            /* it exists */
+            if (rv & FILE_ATTRIBUTE_DIRECTORY) {
+                /* it's a directory */
+                PyErr_SetString(PyExc_ImportError,
+                                "existing directory");
+                return -1;
+            }
+        }
 #endif
 #else /* RISCOS */
-		if (object_exists(path)) {
-			/* it exists */
-			if (isdir(path)) {
-				/* it's a directory */
-				PyErr_SetString(PyExc_ImportError,
-						"existing directory");
-				return -1;
-			}
-		}
+        if (object_exists(path)) {
+            /* it exists */
+            if (isdir(path)) {
+                /* it's a directory */
+                PyErr_SetString(PyExc_ImportError,
+                                "existing directory");
+                return -1;
+            }
+        }
 #endif
-	}
-	return 0;
+    }
+    return 0;
 }
 
 static PyObject *
 NullImporter_find_module(NullImporter *self, PyObject *args)
 {
-	Py_RETURN_NONE;
+    Py_RETURN_NONE;
 }
 
 static PyMethodDef NullImporter_methods[] = {
-	{"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,
-	 "Always return None"
-	},
-	{NULL}  /* Sentinel */
+    {"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,
+     "Always return None"
+    },
+    {NULL}  /* Sentinel */
 };
 
 
 PyTypeObject PyNullImporter_Type = {
-	PyVarObject_HEAD_INIT(NULL, 0)
-	"imp.NullImporter",        /*tp_name*/
-	sizeof(NullImporter),      /*tp_basicsize*/
-	0,                         /*tp_itemsize*/
-	0,                         /*tp_dealloc*/
-	0,                         /*tp_print*/
-	0,                         /*tp_getattr*/
-	0,                         /*tp_setattr*/
-	0,                         /*tp_compare*/
-	0,                         /*tp_repr*/
-	0,                         /*tp_as_number*/
-	0,                         /*tp_as_sequence*/
-	0,                         /*tp_as_mapping*/
-	0,                         /*tp_hash */
-	0,                         /*tp_call*/
-	0,                         /*tp_str*/
-	0,                         /*tp_getattro*/
-	0,                         /*tp_setattro*/
-	0,                         /*tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT,        /*tp_flags*/
-	"Null importer object",    /* tp_doc */
-	0,	                   /* tp_traverse */
-	0,	                   /* tp_clear */
-	0,	                   /* tp_richcompare */
-	0,	                   /* tp_weaklistoffset */
-	0,	                   /* tp_iter */
-	0,	                   /* tp_iternext */
-	NullImporter_methods,      /* tp_methods */
-	0,                         /* tp_members */
-	0,                         /* tp_getset */
-	0,                         /* tp_base */
-	0,                         /* tp_dict */
-	0,                         /* tp_descr_get */
-	0,                         /* tp_descr_set */
-	0,                         /* tp_dictoffset */
-	(initproc)NullImporter_init,      /* tp_init */
-	0,                         /* tp_alloc */
-	PyType_GenericNew          /* tp_new */
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "imp.NullImporter",        /*tp_name*/
+    sizeof(NullImporter),      /*tp_basicsize*/
+    0,                         /*tp_itemsize*/
+    0,                         /*tp_dealloc*/
+    0,                         /*tp_print*/
+    0,                         /*tp_getattr*/
+    0,                         /*tp_setattr*/
+    0,                         /*tp_compare*/
+    0,                         /*tp_repr*/
+    0,                         /*tp_as_number*/
+    0,                         /*tp_as_sequence*/
+    0,                         /*tp_as_mapping*/
+    0,                         /*tp_hash */
+    0,                         /*tp_call*/
+    0,                         /*tp_str*/
+    0,                         /*tp_getattro*/
+    0,                         /*tp_setattro*/
+    0,                         /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT,        /*tp_flags*/
+    "Null importer object",    /* tp_doc */
+    0,                             /* tp_traverse */
+    0,                             /* tp_clear */
+    0,                             /* tp_richcompare */
+    0,                             /* tp_weaklistoffset */
+    0,                             /* tp_iter */
+    0,                             /* tp_iternext */
+    NullImporter_methods,      /* tp_methods */
+    0,                         /* tp_members */
+    0,                         /* tp_getset */
+    0,                         /* tp_base */
+    0,                         /* tp_dict */
+    0,                         /* tp_descr_get */
+    0,                         /* tp_descr_set */
+    0,                         /* tp_dictoffset */
+    (initproc)NullImporter_init,      /* tp_init */
+    0,                         /* tp_alloc */
+    PyType_GenericNew          /* tp_new */
 };
 
 
 PyMODINIT_FUNC
 initimp(void)
 {
-	PyObject *m, *d;
-
-	if (PyType_Ready(&PyNullImporter_Type) < 0)
-		goto failure;
-
-	m = Py_InitModule4("imp", imp_methods, doc_imp,
-			   NULL, PYTHON_API_VERSION);
-	if (m == NULL)
-		goto failure;
-	d = PyModule_GetDict(m);
-	if (d == NULL)
-		goto failure;
-
-	if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;
-	if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;
-	if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;
-	if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;
-	if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;
-	if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;
-	if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;
-	if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;
-	if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;
-	if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;
-
-	Py_INCREF(&PyNullImporter_Type);
-	PyModule_AddObject(m, "NullImporter", (PyObject *)&PyNullImporter_Type);
+    PyObject *m, *d;
+
+    if (PyType_Ready(&PyNullImporter_Type) < 0)
+        goto failure;
+
+    m = Py_InitModule4("imp", imp_methods, doc_imp,
+                       NULL, PYTHON_API_VERSION);
+    if (m == NULL)
+        goto failure;
+    d = PyModule_GetDict(m);
+    if (d == NULL)
+        goto failure;
+
+    if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;
+    if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;
+    if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;
+    if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;
+    if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;
+    if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;
+    if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;
+    if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;
+    if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;
+    if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;
+
+    Py_INCREF(&PyNullImporter_Type);
+    PyModule_AddObject(m, "NullImporter", (PyObject *)&PyNullImporter_Type);
   failure:
-	;
+    ;
 }
 
 
@@ -3348,31 +3348,31 @@ initimp(void)
 int
 PyImport_ExtendInittab(struct _inittab *newtab)
 {
-	static struct _inittab *our_copy = NULL;
-	struct _inittab *p;
-	int i, n;
+    static struct _inittab *our_copy = NULL;
+    struct _inittab *p;
+    int i, n;
 
-	/* Count the number of entries in both tables */
-	for (n = 0; newtab[n].name != NULL; n++)
-		;
-	if (n == 0)
-		return 0; /* Nothing to do */
-	for (i = 0; PyImport_Inittab[i].name != NULL; i++)
-		;
+    /* Count the number of entries in both tables */
+    for (n = 0; newtab[n].name != NULL; n++)
+        ;
+    if (n == 0)
+        return 0; /* Nothing to do */
+    for (i = 0; PyImport_Inittab[i].name != NULL; i++)
+        ;
 
-	/* Allocate new memory for the combined table */
-	p = our_copy;
-	PyMem_RESIZE(p, struct _inittab, i+n+1);
-	if (p == NULL)
-		return -1;
+    /* Allocate new memory for the combined table */
+    p = our_copy;
+    PyMem_RESIZE(p, struct _inittab, i+n+1);
+    if (p == NULL)
+        return -1;
 
-	/* Copy the tables into the new memory */
-	if (our_copy != PyImport_Inittab)
-		memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
-	PyImport_Inittab = our_copy = p;
-	memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
+    /* Copy the tables into the new memory */
+    if (our_copy != PyImport_Inittab)
+        memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
+    PyImport_Inittab = our_copy = p;
+    memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
 
-	return 0;
+    return 0;
 }
 
 /* Shorthand to add a single entry given a name and a function */
@@ -3380,14 +3380,14 @@ PyImport_ExtendInittab(struct _inittab *newtab)
 int
 PyImport_AppendInittab(const char *name, void (*initfunc)(void))
 {
-	struct _inittab newtab[2];
+    struct _inittab newtab[2];
 
-	memset(newtab, '\0', sizeof newtab);
+    memset(newtab, '\0', sizeof newtab);
 
-	newtab[0].name = (char *)name;
-	newtab[0].initfunc = initfunc;
+    newtab[0].name = (char *)name;
+    newtab[0].initfunc = initfunc;
 
-	return PyImport_ExtendInittab(newtab);
+    return PyImport_ExtendInittab(newtab);
 }
 
 #ifdef __cplusplus
diff --git a/Python/importdl.c b/Python/importdl.c
index 9c325e4..14c9be8 100644
--- a/Python/importdl.c
+++ b/Python/importdl.c
@@ -13,66 +13,66 @@
 #include "importdl.h"
 
 extern dl_funcptr _PyImport_GetDynLoadFunc(const char *name,
-					   const char *shortname,
-					   const char *pathname, FILE *fp);
+                                           const char *shortname,
+                                           const char *pathname, FILE *fp);
 
 
 
 PyObject *
 _PyImport_LoadDynamicModule(char *name, char *pathname, FILE *fp)
 {
-	PyObject *m;
-	char *lastdot, *shortname, *packagecontext, *oldcontext;
-	dl_funcptr p;
+    PyObject *m;
+    char *lastdot, *shortname, *packagecontext, *oldcontext;
+    dl_funcptr p;
 
-	if ((m = _PyImport_FindExtension(name, pathname)) != NULL) {
-		Py_INCREF(m);
-		return m;
-	}
-	lastdot = strrchr(name, '.');
-	if (lastdot == NULL) {
-		packagecontext = NULL;
-		shortname = name;
-	}
-	else {
-		packagecontext = name;
-		shortname = lastdot+1;
-	}
+    if ((m = _PyImport_FindExtension(name, pathname)) != NULL) {
+        Py_INCREF(m);
+        return m;
+    }
+    lastdot = strrchr(name, '.');
+    if (lastdot == NULL) {
+        packagecontext = NULL;
+        shortname = name;
+    }
+    else {
+        packagecontext = name;
+        shortname = lastdot+1;
+    }
 
-	p = _PyImport_GetDynLoadFunc(name, shortname, pathname, fp);
-	if (PyErr_Occurred())
-		return NULL;
-	if (p == NULL) {
-		PyErr_Format(PyExc_ImportError,
-		   "dynamic module does not define init function (init%.200s)",
-			     shortname);
-		return NULL;
-	}
-        oldcontext = _Py_PackageContext;
-	_Py_PackageContext = packagecontext;
-	(*p)();
-	_Py_PackageContext = oldcontext;
-	if (PyErr_Occurred())
-		return NULL;
+    p = _PyImport_GetDynLoadFunc(name, shortname, pathname, fp);
+    if (PyErr_Occurred())
+        return NULL;
+    if (p == NULL) {
+        PyErr_Format(PyExc_ImportError,
+           "dynamic module does not define init function (init%.200s)",
+                     shortname);
+        return NULL;
+    }
+    oldcontext = _Py_PackageContext;
+    _Py_PackageContext = packagecontext;
+    (*p)();
+    _Py_PackageContext = oldcontext;
+    if (PyErr_Occurred())
+        return NULL;
 
-	m = PyDict_GetItemString(PyImport_GetModuleDict(), name);
-	if (m == NULL) {
-		PyErr_SetString(PyExc_SystemError,
-				"dynamic module not initialized properly");
-		return NULL;
-	}
-	/* Remember the filename as the __file__ attribute */
-	if (PyModule_AddStringConstant(m, "__file__", pathname) < 0)
-		PyErr_Clear(); /* Not important enough to report */
+    m = PyDict_GetItemString(PyImport_GetModuleDict(), name);
+    if (m == NULL) {
+        PyErr_SetString(PyExc_SystemError,
+                        "dynamic module not initialized properly");
+        return NULL;
+    }
+    /* Remember the filename as the __file__ attribute */
+    if (PyModule_AddStringConstant(m, "__file__", pathname) < 0)
+        PyErr_Clear(); /* Not important enough to report */
 
-	if (_PyImport_FixupExtension(name, pathname) == NULL)
-		return NULL;
-	if (Py_VerboseFlag)
-		PySys_WriteStderr(
-			"import %s # dynamically loaded from %s\n",
-			name, pathname);
-	Py_INCREF(m);
-	return m;
+    if (_PyImport_FixupExtension(name, pathname) == NULL)
+        return NULL;
+    if (Py_VerboseFlag)
+        PySys_WriteStderr(
+            "import %s # dynamically loaded from %s\n",
+            name, pathname);
+    Py_INCREF(m);
+    return m;
 }
 
 #endif /* HAVE_DYNAMIC_LOADING */
diff --git a/Python/importdl.h b/Python/importdl.h
index 5a2d45c..b4d21be 100644
--- a/Python/importdl.h
+++ b/Python/importdl.h
@@ -8,28 +8,28 @@ extern "C" {
 
 /* Definitions for dynamic loading of extension modules */
 enum filetype {
-	SEARCH_ERROR,
-	PY_SOURCE,
-	PY_COMPILED,
-	C_EXTENSION,
-	PY_RESOURCE, /* Mac only */
-	PKG_DIRECTORY,
-	C_BUILTIN,
-	PY_FROZEN,
-	PY_CODERESOURCE, /* Mac only */
-	IMP_HOOK
+    SEARCH_ERROR,
+    PY_SOURCE,
+    PY_COMPILED,
+    C_EXTENSION,
+    PY_RESOURCE, /* Mac only */
+    PKG_DIRECTORY,
+    C_BUILTIN,
+    PY_FROZEN,
+    PY_CODERESOURCE, /* Mac only */
+    IMP_HOOK
 };
 
 struct filedescr {
-	char *suffix;
-	char *mode;
-	enum filetype type;
+    char *suffix;
+    char *mode;
+    enum filetype type;
 };
 extern struct filedescr * _PyImport_Filetab;
 extern const struct filedescr _PyImport_DynLoadFiletab[];
 
 extern PyObject *_PyImport_LoadDynamicModule(char *name, char *pathname,
-					     FILE *);
+                                             FILE *);
 
 /* Max length of module suffix searched for -- accommodates "module.slb" */
 #define MAXSUFFIXSIZE 12
diff --git a/Python/mactoolboxglue.c b/Python/mactoolboxglue.c
index 4037d47..92bf3e8 100644
--- a/Python/mactoolboxglue.c
+++ b/Python/mactoolboxglue.c
@@ -4,10 +4,10 @@ The Netherlands.
 
                         All Rights Reserved
 
-Permission to use, copy, modify, and distribute this software and its 
-documentation for any purpose and without fee is hereby granted, 
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
 provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in 
+both that copyright notice and this permission notice appear in
 supporting documentation, and that the names of Stichting Mathematisch
 Centrum or CWI not be used in advertising or publicity pertaining to
 distribution of the software without specific, written prior permission.
@@ -25,45 +25,45 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 #include "Python.h"
 #include "pymactoolbox.h"
-#include <arpa/inet.h>	/* for ntohl, htonl */
+#include <arpa/inet.h>  /* for ntohl, htonl */
 
 
 /* Like strerror() but for Mac OS error numbers */
 char *
 PyMac_StrError(int err)
 {
-	static char buf[256];
-	PyObject *m;
-	PyObject *rv;
-
-	m = PyImport_ImportModuleNoBlock("MacOS");
-	if (!m) {
-		if (Py_VerboseFlag)
-			PyErr_Print();
-		PyErr_Clear();
-		rv = NULL;
-	}
-	else {
-		rv = PyObject_CallMethod(m, "GetErrorString", "i", err);
-		if (!rv)
-			PyErr_Clear();
-	}
-	if (!rv) {
-		buf[0] = '\0';
-	}
-	else {
-		char *input = PyString_AsString(rv);
-		if (!input) {
-			PyErr_Clear();
-			buf[0] = '\0';
-		} else {
-			strncpy(buf, input, sizeof(buf) - 1);
-			buf[sizeof(buf) - 1] = '\0';
-		}
-		Py_DECREF(rv);
-	}
-	Py_XDECREF(m);
-	return buf;
+    static char buf[256];
+    PyObject *m;
+    PyObject *rv;
+
+    m = PyImport_ImportModuleNoBlock("MacOS");
+    if (!m) {
+        if (Py_VerboseFlag)
+            PyErr_Print();
+        PyErr_Clear();
+        rv = NULL;
+    }
+    else {
+        rv = PyObject_CallMethod(m, "GetErrorString", "i", err);
+        if (!rv)
+            PyErr_Clear();
+    }
+    if (!rv) {
+        buf[0] = '\0';
+    }
+    else {
+        char *input = PyString_AsString(rv);
+        if (!input) {
+            PyErr_Clear();
+            buf[0] = '\0';
+        } else {
+            strncpy(buf, input, sizeof(buf) - 1);
+            buf[sizeof(buf) - 1] = '\0';
+        }
+        Py_DECREF(rv);
+    }
+    Py_XDECREF(m);
+    return buf;
 }
 
 /* Exception object shared by all Mac specific modules for Mac OS errors */
@@ -73,36 +73,36 @@ PyObject *PyMac_OSErrException;
 PyObject *
 PyMac_GetOSErrException(void)
 {
-	if (PyMac_OSErrException == NULL)
-		PyMac_OSErrException = PyErr_NewException("MacOS.Error", NULL, NULL);
-	return PyMac_OSErrException;
+    if (PyMac_OSErrException == NULL)
+        PyMac_OSErrException = PyErr_NewException("MacOS.Error", NULL, NULL);
+    return PyMac_OSErrException;
 }
 
 /* Set a MAC-specific error from errno, and return NULL; return None if no error */
-PyObject * 
+PyObject *
 PyErr_Mac(PyObject *eobj, int err)
 {
-	char *msg;
-	PyObject *v;
-	
-	if (err == 0 && !PyErr_Occurred()) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	if (err == -1 && PyErr_Occurred())
-		return NULL;
-	msg = PyMac_StrError(err);
-	v = Py_BuildValue("(is)", err, msg);
-	PyErr_SetObject(eobj, v);
-	Py_DECREF(v);
-	return NULL;
+    char *msg;
+    PyObject *v;
+
+    if (err == 0 && !PyErr_Occurred()) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    if (err == -1 && PyErr_Occurred())
+        return NULL;
+    msg = PyMac_StrError(err);
+    v = Py_BuildValue("(is)", err, msg);
+    PyErr_SetObject(eobj, v);
+    Py_DECREF(v);
+    return NULL;
 }
 
 /* Call PyErr_Mac with PyMac_OSErrException */
 PyObject *
 PyMac_Error(OSErr err)
 {
-	return PyErr_Mac(PyMac_GetOSErrException(), err);
+    return PyErr_Mac(PyMac_GetOSErrException(), err);
 }
 
 
@@ -110,49 +110,49 @@ PyMac_Error(OSErr err)
 OSErr
 PyMac_GetFullPathname(FSSpec *fss, char *path, int len)
 {
-	PyObject *fs, *exc;
-	PyObject *rv = NULL;
-	char *input;
-	OSErr err = noErr;
+    PyObject *fs, *exc;
+    PyObject *rv = NULL;
+    char *input;
+    OSErr err = noErr;
 
-	*path = '\0';
+    *path = '\0';
 
-	fs = PyMac_BuildFSSpec(fss);
-	if (!fs)
-		goto error;
+    fs = PyMac_BuildFSSpec(fss);
+    if (!fs)
+        goto error;
 
-	rv = PyObject_CallMethod(fs, "as_pathname", "");
-	if (!rv)
-		goto error;
+    rv = PyObject_CallMethod(fs, "as_pathname", "");
+    if (!rv)
+        goto error;
 
-	input = PyString_AsString(rv);
-	if (!input)
-		goto error;
+    input = PyString_AsString(rv);
+    if (!input)
+        goto error;
 
-	strncpy(path, input, len - 1);
-	path[len - 1] = '\0';
+    strncpy(path, input, len - 1);
+    path[len - 1] = '\0';
 
-	Py_XDECREF(rv);
-	Py_XDECREF(fs);
-	return err;
+    Py_XDECREF(rv);
+    Py_XDECREF(fs);
+    return err;
 
   error:
-	exc = PyErr_Occurred();
-	if (exc  && PyErr_GivenExceptionMatches(exc,
-						PyMac_GetOSErrException())) {
-		PyObject *args = PyObject_GetAttrString(exc, "args");
-		if (args) {
-			char *ignore;
-			PyArg_ParseTuple(args, "is", &err, &ignore);
-			Py_XDECREF(args);
-		}
-	}
-	if (err == noErr)
-		err = -1;
-	PyErr_Clear();
-	Py_XDECREF(rv);
-	Py_XDECREF(fs);
-	return err;
+    exc = PyErr_Occurred();
+    if (exc  && PyErr_GivenExceptionMatches(exc,
+                                            PyMac_GetOSErrException())) {
+        PyObject *args = PyObject_GetAttrString(exc, "args");
+        if (args) {
+            char *ignore;
+            PyArg_ParseTuple(args, "is", &err, &ignore);
+            Py_XDECREF(args);
+        }
+    }
+    if (err == noErr)
+        err = -1;
+    PyErr_Clear();
+    Py_XDECREF(rv);
+    Py_XDECREF(fs);
+    return err;
 }
 #endif /* !__LP64__ */
 
@@ -160,30 +160,30 @@ PyMac_GetFullPathname(FSSpec *fss, char *path, int len)
 int
 PyMac_GetOSType(PyObject *v, OSType *pr)
 {
-	uint32_t tmp;
-	if (!PyString_Check(v) || PyString_Size(v) != 4) {
-		PyErr_SetString(PyExc_TypeError,
-			"OSType arg must be string of 4 chars");
-		return 0;
-	}
-	memcpy((char *)&tmp, PyString_AsString(v), 4);
-	*pr = (OSType)ntohl(tmp);
-	return 1;
+    uint32_t tmp;
+    if (!PyString_Check(v) || PyString_Size(v) != 4) {
+        PyErr_SetString(PyExc_TypeError,
+            "OSType arg must be string of 4 chars");
+        return 0;
+    }
+    memcpy((char *)&tmp, PyString_AsString(v), 4);
+    *pr = (OSType)ntohl(tmp);
+    return 1;
 }
 
 /* Convert an OSType value to a 4-char string object */
 PyObject *
 PyMac_BuildOSType(OSType t)
 {
-	uint32_t tmp = htonl((uint32_t)t);
-	return PyString_FromStringAndSize((char *)&tmp, 4);
+    uint32_t tmp = htonl((uint32_t)t);
+    return PyString_FromStringAndSize((char *)&tmp, 4);
 }
 
 /* Convert an NumVersion value to a 4-element tuple */
 PyObject *
 PyMac_BuildNumVersion(NumVersion t)
 {
-	return Py_BuildValue("(hhhh)", t.majorRev, t.minorAndBugRev, t.stage, t.nonRelRev);
+    return Py_BuildValue("(hhhh)", t.majorRev, t.minorAndBugRev, t.stage, t.nonRelRev);
 }
 
 
@@ -191,36 +191,36 @@ PyMac_BuildNumVersion(NumVersion t)
 int
 PyMac_GetStr255(PyObject *v, Str255 pbuf)
 {
-	int len;
-	if (!PyString_Check(v) || (len = PyString_Size(v)) > 255) {
-		PyErr_SetString(PyExc_TypeError,
-			"Str255 arg must be string of at most 255 chars");
-		return 0;
-	}
-	pbuf[0] = len;
-	memcpy((char *)(pbuf+1), PyString_AsString(v), len);
-	return 1;
+    int len;
+    if (!PyString_Check(v) || (len = PyString_Size(v)) > 255) {
+        PyErr_SetString(PyExc_TypeError,
+            "Str255 arg must be string of at most 255 chars");
+        return 0;
+    }
+    pbuf[0] = len;
+    memcpy((char *)(pbuf+1), PyString_AsString(v), len);
+    return 1;
 }
 
 /* Convert a Str255 to a Python string object */
 PyObject *
 PyMac_BuildStr255(Str255 s)
 {
-	if ( s == NULL ) {
-		PyErr_SetString(PyExc_SystemError, "Str255 pointer is NULL");
-		return NULL;
-	}
-	return PyString_FromStringAndSize((char *)&s[1], (int)s[0]);
+    if ( s == NULL ) {
+        PyErr_SetString(PyExc_SystemError, "Str255 pointer is NULL");
+        return NULL;
+    }
+    return PyString_FromStringAndSize((char *)&s[1], (int)s[0]);
 }
 
 PyObject *
 PyMac_BuildOptStr255(Str255 s)
 {
-	if ( s == NULL ) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	return PyString_FromStringAndSize((char *)&s[1], (int)s[0]);
+    if ( s == NULL ) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    return PyString_FromStringAndSize((char *)&s[1], (int)s[0]);
 }
 
 
@@ -232,14 +232,14 @@ PyMac_BuildOptStr255(Str255 s)
 int
 PyMac_GetRect(PyObject *v, Rect *r)
 {
-	return PyArg_Parse(v, "(hhhh)", &r->left, &r->top, &r->right, &r->bottom);
+    return PyArg_Parse(v, "(hhhh)", &r->left, &r->top, &r->right, &r->bottom);
 }
 
 /* Convert a Rect to a Python object */
 PyObject *
 PyMac_BuildRect(Rect *r)
 {
-	return Py_BuildValue("(hhhh)", r->left, r->top, r->right, r->bottom);
+    return Py_BuildValue("(hhhh)", r->left, r->top, r->right, r->bottom);
 }
 
 
@@ -250,14 +250,14 @@ PyMac_BuildRect(Rect *r)
 int
 PyMac_GetPoint(PyObject *v, Point *p)
 {
-	return PyArg_Parse(v, "(hh)", &p->h, &p->v);
+    return PyArg_Parse(v, "(hh)", &p->h, &p->v);
 }
 
 /* Convert a Point to a Python object */
 PyObject *
 PyMac_BuildPoint(Point p)
 {
-	return Py_BuildValue("(hh)", p.h, p.v);
+    return Py_BuildValue("(hh)", p.h, p.v);
 }
 
 
@@ -266,73 +266,73 @@ PyMac_BuildPoint(Point p)
 int
 PyMac_GetEventRecord(PyObject *v, EventRecord *e)
 {
-	return PyArg_Parse(v, "(Hkk(hh)H)",
-	                   &e->what,
-	                   &e->message,
-	                   &e->when,
-	                   &e->where.h,
-	                   &e->where.v,                   
-	                   &e->modifiers);
+    return PyArg_Parse(v, "(Hkk(hh)H)",
+                       &e->what,
+                       &e->message,
+                       &e->when,
+                       &e->where.h,
+                       &e->where.v,
+                       &e->modifiers);
 }
 
 /* Convert a Rect to an EventRecord object */
 PyObject *
 PyMac_BuildEventRecord(EventRecord *e)
 {
-	return Py_BuildValue("(hll(hh)h)",
-	                     e->what,
-	                     e->message,
-	                     e->when,
-	                     e->where.h,
-	                     e->where.v,
-	                     e->modifiers);
+    return Py_BuildValue("(hll(hh)h)",
+                         e->what,
+                         e->message,
+                         e->when,
+                         e->where.h,
+                         e->where.v,
+                         e->modifiers);
 }
 
 /* Convert Python object to Fixed */
 int
 PyMac_GetFixed(PyObject *v, Fixed *f)
 {
-	double d;
-	
-	if( !PyArg_Parse(v, "d", &d))
-		return 0;
-	*f = (Fixed)(d * 0x10000);
-	return 1;
+    double d;
+
+    if( !PyArg_Parse(v, "d", &d))
+        return 0;
+    *f = (Fixed)(d * 0x10000);
+    return 1;
 }
 
 /* Convert a Fixed to a Python object */
 PyObject *
 PyMac_BuildFixed(Fixed f)
 {
-	double d;
-	
-	d = f;
-	d = d / 0x10000;
-	return Py_BuildValue("d", d);
+    double d;
+
+    d = f;
+    d = d / 0x10000;
+    return Py_BuildValue("d", d);
 }
 
 /* Convert wide to/from Python int or (hi, lo) tuple. XXXX Should use Python longs */
 int
 PyMac_Getwide(PyObject *v, wide *rv)
 {
-	if (PyInt_Check(v)) {
-		rv->hi = 0;
-		rv->lo = PyInt_AsLong(v);
-		if( rv->lo & 0x80000000 )
-			rv->hi = -1;
-		return 1;
-	}
-	return PyArg_Parse(v, "(kk)", &rv->hi, &rv->lo);
+    if (PyInt_Check(v)) {
+        rv->hi = 0;
+        rv->lo = PyInt_AsLong(v);
+        if( rv->lo & 0x80000000 )
+            rv->hi = -1;
+        return 1;
+    }
+    return PyArg_Parse(v, "(kk)", &rv->hi, &rv->lo);
 }
 
 
 PyObject *
 PyMac_Buildwide(wide *w)
 {
-	if ( (w->hi == 0 && (w->lo & 0x80000000) == 0) ||
-	     (w->hi == -1 && (w->lo & 0x80000000) ) )
-		return PyInt_FromLong(w->lo);
-	return Py_BuildValue("(ll)", w->hi, w->lo);
+    if ( (w->hi == 0 && (w->lo & 0x80000000) == 0) ||
+         (w->hi == -1 && (w->lo & 0x80000000) ) )
+        return PyInt_FromLong(w->lo);
+    return Py_BuildValue("(ll)", w->hi, w->lo);
 }
 
 #ifdef USE_TOOLBOX_OBJECT_GLUE
@@ -358,8 +358,8 @@ PyObject *routinename(object cobj) { \
     if (!PyMacGluePtr_##routinename) { \
        if (!PyImport_ImportModule(module)) return NULL; \
        if (!PyMacGluePtr_##routinename) { \
-           PyErr_SetString(PyExc_ImportError, "Module did not provide routine: " module ": " #routinename); \
-           return NULL; \
+       PyErr_SetString(PyExc_ImportError, "Module did not provide routine: " module ": " #routinename); \
+       return NULL; \
        } \
     } \
     return (*PyMacGluePtr_##routinename)(cobj); \
@@ -372,8 +372,8 @@ int routinename(PyObject *pyobj, object *cobj) { \
     if (!PyMacGluePtr_##routinename) { \
        if (!PyImport_ImportModule(module)) return 0; \
        if (!PyMacGluePtr_##routinename) { \
-           PyErr_SetString(PyExc_ImportError, "Module did not provide routine: " module ": " #routinename); \
-           return 0; \
+       PyErr_SetString(PyExc_ImportError, "Module did not provide routine: " module ": " #routinename); \
+       return 0; \
        } \
     } \
     return (*PyMacGluePtr_##routinename)(pyobj, cobj); \
diff --git a/Python/marshal.c b/Python/marshal.c
index 14f7134..faca027 100644
--- a/Python/marshal.c
+++ b/Python/marshal.c
@@ -19,30 +19,30 @@
  */
 #define MAX_MARSHAL_STACK_DEPTH 2000
 
-#define TYPE_NULL		'0'
-#define TYPE_NONE		'N'
-#define TYPE_FALSE		'F'
-#define TYPE_TRUE		'T'
-#define TYPE_STOPITER		'S'
-#define TYPE_ELLIPSIS   	'.'
-#define TYPE_INT		'i'
-#define TYPE_INT64		'I'
-#define TYPE_FLOAT		'f'
-#define TYPE_BINARY_FLOAT	'g'
-#define TYPE_COMPLEX		'x'
-#define TYPE_BINARY_COMPLEX	'y'
-#define TYPE_LONG		'l'
-#define TYPE_STRING		's'
-#define TYPE_INTERNED		't'
-#define TYPE_STRINGREF		'R'
-#define TYPE_TUPLE		'('
-#define TYPE_LIST		'['
-#define TYPE_DICT		'{'
-#define TYPE_CODE		'c'
-#define TYPE_UNICODE		'u'
-#define TYPE_UNKNOWN		'?'
-#define TYPE_SET		'<'
-#define TYPE_FROZENSET  	'>'
+#define TYPE_NULL               '0'
+#define TYPE_NONE               'N'
+#define TYPE_FALSE              'F'
+#define TYPE_TRUE               'T'
+#define TYPE_STOPITER           'S'
+#define TYPE_ELLIPSIS           '.'
+#define TYPE_INT                'i'
+#define TYPE_INT64              'I'
+#define TYPE_FLOAT              'f'
+#define TYPE_BINARY_FLOAT       'g'
+#define TYPE_COMPLEX            'x'
+#define TYPE_BINARY_COMPLEX     'y'
+#define TYPE_LONG               'l'
+#define TYPE_STRING             's'
+#define TYPE_INTERNED           't'
+#define TYPE_STRINGREF          'R'
+#define TYPE_TUPLE              '('
+#define TYPE_LIST               '['
+#define TYPE_DICT               '{'
+#define TYPE_CODE               'c'
+#define TYPE_UNICODE            'u'
+#define TYPE_UNKNOWN            '?'
+#define TYPE_SET                '<'
+#define TYPE_FROZENSET          '>'
 
 #define WFERR_OK 0
 #define WFERR_UNMARSHALLABLE 1
@@ -50,79 +50,79 @@
 #define WFERR_NOMEMORY 3
 
 typedef struct {
-	FILE *fp;
-	int error;  /* see WFERR_* values */
-	int depth;
-	/* If fp == NULL, the following are valid: */
-	PyObject *str;
-	char *ptr;
-	char *end;
-	PyObject *strings; /* dict on marshal, list on unmarshal */
-	int version;
+    FILE *fp;
+    int error;  /* see WFERR_* values */
+    int depth;
+    /* If fp == NULL, the following are valid: */
+    PyObject *str;
+    char *ptr;
+    char *end;
+    PyObject *strings; /* dict on marshal, list on unmarshal */
+    int version;
 } WFILE;
 
 #define w_byte(c, p) if (((p)->fp)) putc((c), (p)->fp); \
-		      else if ((p)->ptr != (p)->end) *(p)->ptr++ = (c); \
-			   else w_more(c, p)
+                      else if ((p)->ptr != (p)->end) *(p)->ptr++ = (c); \
+                           else w_more(c, p)
 
 static void
 w_more(int c, WFILE *p)
 {
-	Py_ssize_t size, newsize;
-	if (p->str == NULL)
-		return; /* An error already occurred */
-	size = PyString_Size(p->str);
-	newsize = size + size + 1024;
-	if (newsize > 32*1024*1024) {
-		newsize = size + (size >> 3);	/* 12.5% overallocation */
-	}
-	if (_PyString_Resize(&p->str, newsize) != 0) {
-		p->ptr = p->end = NULL;
-	}
-	else {
-		p->ptr = PyString_AS_STRING((PyStringObject *)p->str) + size;
-		p->end =
-			PyString_AS_STRING((PyStringObject *)p->str) + newsize;
-		*p->ptr++ = Py_SAFE_DOWNCAST(c, int, char);
-	}
+    Py_ssize_t size, newsize;
+    if (p->str == NULL)
+        return; /* An error already occurred */
+    size = PyString_Size(p->str);
+    newsize = size + size + 1024;
+    if (newsize > 32*1024*1024) {
+        newsize = size + (size >> 3);           /* 12.5% overallocation */
+    }
+    if (_PyString_Resize(&p->str, newsize) != 0) {
+        p->ptr = p->end = NULL;
+    }
+    else {
+        p->ptr = PyString_AS_STRING((PyStringObject *)p->str) + size;
+        p->end =
+            PyString_AS_STRING((PyStringObject *)p->str) + newsize;
+        *p->ptr++ = Py_SAFE_DOWNCAST(c, int, char);
+    }
 }
 
 static void
 w_string(char *s, int n, WFILE *p)
 {
-	if (p->fp != NULL) {
-		fwrite(s, 1, n, p->fp);
-	}
-	else {
-		while (--n >= 0) {
-			w_byte(*s, p);
-			s++;
-		}
-	}
+    if (p->fp != NULL) {
+        fwrite(s, 1, n, p->fp);
+    }
+    else {
+        while (--n >= 0) {
+            w_byte(*s, p);
+            s++;
+        }
+    }
 }
 
 static void
 w_short(int x, WFILE *p)
 {
-	w_byte((char)( x      & 0xff), p);
-	w_byte((char)((x>> 8) & 0xff), p);
+    w_byte((char)( x      & 0xff), p);
+    w_byte((char)((x>> 8) & 0xff), p);
 }
 
 static void
 w_long(long x, WFILE *p)
 {
-	w_byte((char)( x      & 0xff), p);
-	w_byte((char)((x>> 8) & 0xff), p);
-	w_byte((char)((x>>16) & 0xff), p);
-	w_byte((char)((x>>24) & 0xff), p);
+    w_byte((char)( x      & 0xff), p);
+    w_byte((char)((x>> 8) & 0xff), p);
+    w_byte((char)((x>>16) & 0xff), p);
+    w_byte((char)((x>>24) & 0xff), p);
 }
 
 #if SIZEOF_LONG > 4
 static void
 w_long64(long x, WFILE *p)
 {
-	w_long(x, p);
-	w_long(x>>32, p);
+    w_long(x, p);
+    w_long(x>>32, p);
 }
 #endif
 
@@ -141,337 +141,337 @@ w_long64(long x, WFILE *p)
 static void
 w_PyLong(const PyLongObject *ob, WFILE *p)
 {
-	Py_ssize_t i, j, n, l;
-	digit d;
-
-	w_byte(TYPE_LONG, p);
-	if (Py_SIZE(ob) == 0) {
-		w_long((long)0, p);
-		return;
-	}
-
-	/* set l to number of base PyLong_MARSHAL_BASE digits */
-	n = ABS(Py_SIZE(ob));
-	l = (n-1) * PyLong_MARSHAL_RATIO;
-	d = ob->ob_digit[n-1];
-	assert(d != 0); /* a PyLong is always normalized */
-	do {
-		d >>= PyLong_MARSHAL_SHIFT;
-		l++;
-	} while (d != 0);
-	w_long((long)(Py_SIZE(ob) > 0 ? l : -l), p);
-
-	for (i=0; i < n-1; i++) {
-		d = ob->ob_digit[i];
-		for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
-			w_short(d & PyLong_MARSHAL_MASK, p);
-			d >>= PyLong_MARSHAL_SHIFT;
-		}
-		assert (d == 0);
-	}
-	d = ob->ob_digit[n-1];
-	do {
-		w_short(d & PyLong_MARSHAL_MASK, p);
-		d >>= PyLong_MARSHAL_SHIFT;
-	} while (d != 0);
+    Py_ssize_t i, j, n, l;
+    digit d;
+
+    w_byte(TYPE_LONG, p);
+    if (Py_SIZE(ob) == 0) {
+        w_long((long)0, p);
+        return;
+    }
+
+    /* set l to number of base PyLong_MARSHAL_BASE digits */
+    n = ABS(Py_SIZE(ob));
+    l = (n-1) * PyLong_MARSHAL_RATIO;
+    d = ob->ob_digit[n-1];
+    assert(d != 0); /* a PyLong is always normalized */
+    do {
+        d >>= PyLong_MARSHAL_SHIFT;
+        l++;
+    } while (d != 0);
+    w_long((long)(Py_SIZE(ob) > 0 ? l : -l), p);
+
+    for (i=0; i < n-1; i++) {
+        d = ob->ob_digit[i];
+        for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
+            w_short(d & PyLong_MARSHAL_MASK, p);
+            d >>= PyLong_MARSHAL_SHIFT;
+        }
+        assert (d == 0);
+    }
+    d = ob->ob_digit[n-1];
+    do {
+        w_short(d & PyLong_MARSHAL_MASK, p);
+        d >>= PyLong_MARSHAL_SHIFT;
+    } while (d != 0);
 }
 
 static void
 w_object(PyObject *v, WFILE *p)
 {
-	Py_ssize_t i, n;
-
-	p->depth++;
-
-	if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
-		p->error = WFERR_NESTEDTOODEEP;
-	}
-	else if (v == NULL) {
-		w_byte(TYPE_NULL, p);
-	}
-	else if (v == Py_None) {
-		w_byte(TYPE_NONE, p);
-	}
-	else if (v == PyExc_StopIteration) {
-		w_byte(TYPE_STOPITER, p);
-	}
-	else if (v == Py_Ellipsis) {
-	        w_byte(TYPE_ELLIPSIS, p);
-	}
-	else if (v == Py_False) {
-	        w_byte(TYPE_FALSE, p);
-	}
-	else if (v == Py_True) {
-	        w_byte(TYPE_TRUE, p);
-	}
-	else if (PyInt_CheckExact(v)) {
-		long x = PyInt_AS_LONG((PyIntObject *)v);
+    Py_ssize_t i, n;
+
+    p->depth++;
+
+    if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
+        p->error = WFERR_NESTEDTOODEEP;
+    }
+    else if (v == NULL) {
+        w_byte(TYPE_NULL, p);
+    }
+    else if (v == Py_None) {
+        w_byte(TYPE_NONE, p);
+    }
+    else if (v == PyExc_StopIteration) {
+        w_byte(TYPE_STOPITER, p);
+    }
+    else if (v == Py_Ellipsis) {
+        w_byte(TYPE_ELLIPSIS, p);
+    }
+    else if (v == Py_False) {
+        w_byte(TYPE_FALSE, p);
+    }
+    else if (v == Py_True) {
+        w_byte(TYPE_TRUE, p);
+    }
+    else if (PyInt_CheckExact(v)) {
+        long x = PyInt_AS_LONG((PyIntObject *)v);
 #if SIZEOF_LONG > 4
-		long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
-		if (y && y != -1) {
-			w_byte(TYPE_INT64, p);
-			w_long64(x, p);
-		}
-		else
+        long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
+        if (y && y != -1) {
+            w_byte(TYPE_INT64, p);
+            w_long64(x, p);
+        }
+        else
 #endif
-			{
-			w_byte(TYPE_INT, p);
-			w_long(x, p);
-		}
-	}
-	else if (PyLong_CheckExact(v)) {
-		PyLongObject *ob = (PyLongObject *)v;
-		w_PyLong(ob, p);
-	}
-	else if (PyFloat_CheckExact(v)) {
-		if (p->version > 1) {
-			unsigned char buf[8];
-			if (_PyFloat_Pack8(PyFloat_AsDouble(v), 
-					   buf, 1) < 0) {
-				p->error = WFERR_UNMARSHALLABLE;
-				return;
-			}
-			w_byte(TYPE_BINARY_FLOAT, p);
-			w_string((char*)buf, 8, p);
-		}
-		else {
-			char *buf = PyOS_double_to_string(PyFloat_AS_DOUBLE(v),
-                                                          'g', 17, 0, NULL);
-			if (!buf) {
-				p->error = WFERR_NOMEMORY;
-				return;
-			}
-			n = strlen(buf);
-			w_byte(TYPE_FLOAT, p);
-			w_byte((int)n, p);
-			w_string(buf, (int)n, p);
-			PyMem_Free(buf);
-		}
-	}
+            {
+            w_byte(TYPE_INT, p);
+            w_long(x, p);
+        }
+    }
+    else if (PyLong_CheckExact(v)) {
+        PyLongObject *ob = (PyLongObject *)v;
+        w_PyLong(ob, p);
+    }
+    else if (PyFloat_CheckExact(v)) {
+        if (p->version > 1) {
+            unsigned char buf[8];
+            if (_PyFloat_Pack8(PyFloat_AsDouble(v),
+                               buf, 1) < 0) {
+                p->error = WFERR_UNMARSHALLABLE;
+                return;
+            }
+            w_byte(TYPE_BINARY_FLOAT, p);
+            w_string((char*)buf, 8, p);
+        }
+        else {
+            char *buf = PyOS_double_to_string(PyFloat_AS_DOUBLE(v),
+                                              'g', 17, 0, NULL);
+            if (!buf) {
+                p->error = WFERR_NOMEMORY;
+                return;
+            }
+            n = strlen(buf);
+            w_byte(TYPE_FLOAT, p);
+            w_byte((int)n, p);
+            w_string(buf, (int)n, p);
+            PyMem_Free(buf);
+        }
+    }
 #ifndef WITHOUT_COMPLEX
-	else if (PyComplex_CheckExact(v)) {
-		if (p->version > 1) {
-			unsigned char buf[8];
-			if (_PyFloat_Pack8(PyComplex_RealAsDouble(v),
-					   buf, 1) < 0) {
-				p->error = WFERR_UNMARSHALLABLE;
-				return;
-			}
-			w_byte(TYPE_BINARY_COMPLEX, p);
-			w_string((char*)buf, 8, p);
-			if (_PyFloat_Pack8(PyComplex_ImagAsDouble(v), 
-					   buf, 1) < 0) {
-				p->error = WFERR_UNMARSHALLABLE;
-				return;
-			}
-			w_string((char*)buf, 8, p);
-		}
-		else {
-			char *buf;
-			w_byte(TYPE_COMPLEX, p);
-			buf = PyOS_double_to_string(PyComplex_RealAsDouble(v),
-                                                    'g', 17, 0, NULL);
-			if (!buf) {
-				p->error = WFERR_NOMEMORY;
-				return;
-			}
-			n = strlen(buf);
-			w_byte((int)n, p);
-			w_string(buf, (int)n, p);
-			PyMem_Free(buf);
-			buf = PyOS_double_to_string(PyComplex_ImagAsDouble(v),
-                                                    'g', 17, 0, NULL);
-			if (!buf) {
-				p->error = WFERR_NOMEMORY;
-				return;
-			}
-			n = strlen(buf);
-			w_byte((int)n, p);
-			w_string(buf, (int)n, p);
-			PyMem_Free(buf);
-		}
-	}
+    else if (PyComplex_CheckExact(v)) {
+        if (p->version > 1) {
+            unsigned char buf[8];
+            if (_PyFloat_Pack8(PyComplex_RealAsDouble(v),
+                               buf, 1) < 0) {
+                p->error = WFERR_UNMARSHALLABLE;
+                return;
+            }
+            w_byte(TYPE_BINARY_COMPLEX, p);
+            w_string((char*)buf, 8, p);
+            if (_PyFloat_Pack8(PyComplex_ImagAsDouble(v),
+                               buf, 1) < 0) {
+                p->error = WFERR_UNMARSHALLABLE;
+                return;
+            }
+            w_string((char*)buf, 8, p);
+        }
+        else {
+            char *buf;
+            w_byte(TYPE_COMPLEX, p);
+            buf = PyOS_double_to_string(PyComplex_RealAsDouble(v),
+                                        'g', 17, 0, NULL);
+            if (!buf) {
+                p->error = WFERR_NOMEMORY;
+                return;
+            }
+            n = strlen(buf);
+            w_byte((int)n, p);
+            w_string(buf, (int)n, p);
+            PyMem_Free(buf);
+            buf = PyOS_double_to_string(PyComplex_ImagAsDouble(v),
+                                        'g', 17, 0, NULL);
+            if (!buf) {
+                p->error = WFERR_NOMEMORY;
+                return;
+            }
+            n = strlen(buf);
+            w_byte((int)n, p);
+            w_string(buf, (int)n, p);
+            PyMem_Free(buf);
+        }
+    }
 #endif
-	else if (PyString_CheckExact(v)) {
-		if (p->strings && PyString_CHECK_INTERNED(v)) {
-			PyObject *o = PyDict_GetItem(p->strings, v);
-			if (o) {
-				long w = PyInt_AsLong(o);
-				w_byte(TYPE_STRINGREF, p);
-				w_long(w, p);
-				goto exit;
-			}
-			else {
-				int ok;
-				o = PyInt_FromSsize_t(PyDict_Size(p->strings));
-				ok = o &&
-				     PyDict_SetItem(p->strings, v, o) >= 0;
-				Py_XDECREF(o);
-				if (!ok) {
-					p->depth--;
-					p->error = WFERR_UNMARSHALLABLE;
-					return;
-				}
-				w_byte(TYPE_INTERNED, p);
-			}
-		}
-		else {
-			w_byte(TYPE_STRING, p);
-		}
-		n = PyString_GET_SIZE(v);
-		if (n > INT_MAX) {
-			/* huge strings are not supported */
-			p->depth--;
-			p->error = WFERR_UNMARSHALLABLE;
-			return;
-		}
-		w_long((long)n, p);
-		w_string(PyString_AS_STRING(v), (int)n, p);
-	}
+    else if (PyString_CheckExact(v)) {
+        if (p->strings && PyString_CHECK_INTERNED(v)) {
+            PyObject *o = PyDict_GetItem(p->strings, v);
+            if (o) {
+                long w = PyInt_AsLong(o);
+                w_byte(TYPE_STRINGREF, p);
+                w_long(w, p);
+                goto exit;
+            }
+            else {
+                int ok;
+                o = PyInt_FromSsize_t(PyDict_Size(p->strings));
+                ok = o &&
+                     PyDict_SetItem(p->strings, v, o) >= 0;
+                Py_XDECREF(o);
+                if (!ok) {
+                    p->depth--;
+                    p->error = WFERR_UNMARSHALLABLE;
+                    return;
+                }
+                w_byte(TYPE_INTERNED, p);
+            }
+        }
+        else {
+            w_byte(TYPE_STRING, p);
+        }
+        n = PyString_GET_SIZE(v);
+        if (n > INT_MAX) {
+            /* huge strings are not supported */
+            p->depth--;
+            p->error = WFERR_UNMARSHALLABLE;
+            return;
+        }
+        w_long((long)n, p);
+        w_string(PyString_AS_STRING(v), (int)n, p);
+    }
 #ifdef Py_USING_UNICODE
-	else if (PyUnicode_CheckExact(v)) {
-	        PyObject *utf8;
-		utf8 = PyUnicode_AsUTF8String(v);
-		if (utf8 == NULL) {
-			p->depth--;
-			p->error = WFERR_UNMARSHALLABLE;
-			return;
-		}
-		w_byte(TYPE_UNICODE, p);
-		n = PyString_GET_SIZE(utf8);
-		if (n > INT_MAX) {
-			p->depth--;
-			p->error = WFERR_UNMARSHALLABLE;
-			return;
-		}
-		w_long((long)n, p);
-		w_string(PyString_AS_STRING(utf8), (int)n, p);
-		Py_DECREF(utf8);
-	}
+    else if (PyUnicode_CheckExact(v)) {
+        PyObject *utf8;
+        utf8 = PyUnicode_AsUTF8String(v);
+        if (utf8 == NULL) {
+            p->depth--;
+            p->error = WFERR_UNMARSHALLABLE;
+            return;
+        }
+        w_byte(TYPE_UNICODE, p);
+        n = PyString_GET_SIZE(utf8);
+        if (n > INT_MAX) {
+            p->depth--;
+            p->error = WFERR_UNMARSHALLABLE;
+            return;
+        }
+        w_long((long)n, p);
+        w_string(PyString_AS_STRING(utf8), (int)n, p);
+        Py_DECREF(utf8);
+    }
 #endif
-	else if (PyTuple_CheckExact(v)) {
-		w_byte(TYPE_TUPLE, p);
-		n = PyTuple_Size(v);
-		w_long((long)n, p);
-		for (i = 0; i < n; i++) {
-			w_object(PyTuple_GET_ITEM(v, i), p);
-		}
-	}
-	else if (PyList_CheckExact(v)) {
-		w_byte(TYPE_LIST, p);
-		n = PyList_GET_SIZE(v);
-		w_long((long)n, p);
-		for (i = 0; i < n; i++) {
-			w_object(PyList_GET_ITEM(v, i), p);
-		}
-	}
-	else if (PyDict_CheckExact(v)) {
-		Py_ssize_t pos;
-		PyObject *key, *value;
-		w_byte(TYPE_DICT, p);
-		/* This one is NULL object terminated! */
-		pos = 0;
-		while (PyDict_Next(v, &pos, &key, &value)) {
-			w_object(key, p);
-			w_object(value, p);
-		}
-		w_object((PyObject *)NULL, p);
-	}
-	else if (PyAnySet_CheckExact(v)) {
-		PyObject *value, *it;
-
-		if (PyObject_TypeCheck(v, &PySet_Type))
-			w_byte(TYPE_SET, p);
-		else
-			w_byte(TYPE_FROZENSET, p);
-		n = PyObject_Size(v);
-		if (n == -1) {
-			p->depth--;
-			p->error = WFERR_UNMARSHALLABLE;
-			return;
-		}
-		w_long((long)n, p);
-		it = PyObject_GetIter(v);
-		if (it == NULL) {
-			p->depth--;
-			p->error = WFERR_UNMARSHALLABLE;
-			return;
-		}
-		while ((value = PyIter_Next(it)) != NULL) {
-			w_object(value, p);
-			Py_DECREF(value);
-		}
-		Py_DECREF(it);
-		if (PyErr_Occurred()) {
-			p->depth--;
-			p->error = WFERR_UNMARSHALLABLE;
-			return;
-		}
-	}
-	else if (PyCode_Check(v)) {
-		PyCodeObject *co = (PyCodeObject *)v;
-		w_byte(TYPE_CODE, p);
-		w_long(co->co_argcount, p);
-		w_long(co->co_nlocals, p);
-		w_long(co->co_stacksize, p);
-		w_long(co->co_flags, p);
-		w_object(co->co_code, p);
-		w_object(co->co_consts, p);
-		w_object(co->co_names, p);
-		w_object(co->co_varnames, p);
-		w_object(co->co_freevars, p);
-		w_object(co->co_cellvars, p);
-		w_object(co->co_filename, p);
-		w_object(co->co_name, p);
-		w_long(co->co_firstlineno, p);
-		w_object(co->co_lnotab, p);
-	}
-	else if (PyObject_CheckReadBuffer(v)) {
-		/* Write unknown buffer-style objects as a string */
-		char *s;
-		PyBufferProcs *pb = v->ob_type->tp_as_buffer;
-		w_byte(TYPE_STRING, p);
-		n = (*pb->bf_getreadbuffer)(v, 0, (void **)&s);
-		if (n > INT_MAX) {
-			p->depth--;
-			p->error = WFERR_UNMARSHALLABLE;
-			return;
-		}
-		w_long((long)n, p);
-		w_string(s, (int)n, p);
-	}
-	else {
-		w_byte(TYPE_UNKNOWN, p);
-		p->error = WFERR_UNMARSHALLABLE;
-	}
+    else if (PyTuple_CheckExact(v)) {
+        w_byte(TYPE_TUPLE, p);
+        n = PyTuple_Size(v);
+        w_long((long)n, p);
+        for (i = 0; i < n; i++) {
+            w_object(PyTuple_GET_ITEM(v, i), p);
+        }
+    }
+    else if (PyList_CheckExact(v)) {
+        w_byte(TYPE_LIST, p);
+        n = PyList_GET_SIZE(v);
+        w_long((long)n, p);
+        for (i = 0; i < n; i++) {
+            w_object(PyList_GET_ITEM(v, i), p);
+        }
+    }
+    else if (PyDict_CheckExact(v)) {
+        Py_ssize_t pos;
+        PyObject *key, *value;
+        w_byte(TYPE_DICT, p);
+        /* This one is NULL object terminated! */
+        pos = 0;
+        while (PyDict_Next(v, &pos, &key, &value)) {
+            w_object(key, p);
+            w_object(value, p);
+        }
+        w_object((PyObject *)NULL, p);
+    }
+    else if (PyAnySet_CheckExact(v)) {
+        PyObject *value, *it;
+
+        if (PyObject_TypeCheck(v, &PySet_Type))
+            w_byte(TYPE_SET, p);
+        else
+            w_byte(TYPE_FROZENSET, p);
+        n = PyObject_Size(v);
+        if (n == -1) {
+            p->depth--;
+            p->error = WFERR_UNMARSHALLABLE;
+            return;
+        }
+        w_long((long)n, p);
+        it = PyObject_GetIter(v);
+        if (it == NULL) {
+            p->depth--;
+            p->error = WFERR_UNMARSHALLABLE;
+            return;
+        }
+        while ((value = PyIter_Next(it)) != NULL) {
+            w_object(value, p);
+            Py_DECREF(value);
+        }
+        Py_DECREF(it);
+        if (PyErr_Occurred()) {
+            p->depth--;
+            p->error = WFERR_UNMARSHALLABLE;
+            return;
+        }
+    }
+    else if (PyCode_Check(v)) {
+        PyCodeObject *co = (PyCodeObject *)v;
+        w_byte(TYPE_CODE, p);
+        w_long(co->co_argcount, p);
+        w_long(co->co_nlocals, p);
+        w_long(co->co_stacksize, p);
+        w_long(co->co_flags, p);
+        w_object(co->co_code, p);
+        w_object(co->co_consts, p);
+        w_object(co->co_names, p);
+        w_object(co->co_varnames, p);
+        w_object(co->co_freevars, p);
+        w_object(co->co_cellvars, p);
+        w_object(co->co_filename, p);
+        w_object(co->co_name, p);
+        w_long(co->co_firstlineno, p);
+        w_object(co->co_lnotab, p);
+    }
+    else if (PyObject_CheckReadBuffer(v)) {
+        /* Write unknown buffer-style objects as a string */
+        char *s;
+        PyBufferProcs *pb = v->ob_type->tp_as_buffer;
+        w_byte(TYPE_STRING, p);
+        n = (*pb->bf_getreadbuffer)(v, 0, (void **)&s);
+        if (n > INT_MAX) {
+            p->depth--;
+            p->error = WFERR_UNMARSHALLABLE;
+            return;
+        }
+        w_long((long)n, p);
+        w_string(s, (int)n, p);
+    }
+    else {
+        w_byte(TYPE_UNKNOWN, p);
+        p->error = WFERR_UNMARSHALLABLE;
+    }
    exit:
-	p->depth--;
+    p->depth--;
 }
 
 /* version currently has no effect for writing longs. */
 void
 PyMarshal_WriteLongToFile(long x, FILE *fp, int version)
 {
-	WFILE wf;
-	wf.fp = fp;
-	wf.error = WFERR_OK;
-	wf.depth = 0;
-	wf.strings = NULL;
-	wf.version = version;
-	w_long(x, &wf);
+    WFILE wf;
+    wf.fp = fp;
+    wf.error = WFERR_OK;
+    wf.depth = 0;
+    wf.strings = NULL;
+    wf.version = version;
+    w_long(x, &wf);
 }
 
 void
 PyMarshal_WriteObjectToFile(PyObject *x, FILE *fp, int version)
 {
-	WFILE wf;
-	wf.fp = fp;
-	wf.error = WFERR_OK;
-	wf.depth = 0;
-	wf.strings = (version > 0) ? PyDict_New() : NULL;
-	wf.version = version;
-	w_object(x, &wf);
-	Py_XDECREF(wf.strings);
+    WFILE wf;
+    wf.fp = fp;
+    wf.error = WFERR_OK;
+    wf.depth = 0;
+    wf.strings = (version > 0) ? PyDict_New() : NULL;
+    wf.version = version;
+    w_object(x, &wf);
+    Py_XDECREF(wf.strings);
 }
 
 typedef WFILE RFILE; /* Same struct with different invariants */
@@ -483,49 +483,49 @@ typedef WFILE RFILE; /* Same struct with different invariants */
 static int
 r_string(char *s, int n, RFILE *p)
 {
-	if (p->fp != NULL)
-		/* The result fits into int because it must be <=n. */
-		return (int)fread(s, 1, n, p->fp);
-	if (p->end - p->ptr < n)
-		n = (int)(p->end - p->ptr);
-	memcpy(s, p->ptr, n);
-	p->ptr += n;
-	return n;
+    if (p->fp != NULL)
+        /* The result fits into int because it must be <=n. */
+        return (int)fread(s, 1, n, p->fp);
+    if (p->end - p->ptr < n)
+        n = (int)(p->end - p->ptr);
+    memcpy(s, p->ptr, n);
+    p->ptr += n;
+    return n;
 }
 
 static int
 r_short(RFILE *p)
 {
-	register short x;
-	x = r_byte(p);
-	x |= r_byte(p) << 8;
-	/* Sign-extension, in case short greater than 16 bits */
-	x |= -(x & 0x8000);
-	return x;
+    register short x;
+    x = r_byte(p);
+    x |= r_byte(p) << 8;
+    /* Sign-extension, in case short greater than 16 bits */
+    x |= -(x & 0x8000);
+    return x;
 }
 
 static long
 r_long(RFILE *p)
 {
-	register long x;
-	register FILE *fp = p->fp;
-	if (fp) {
-		x = getc(fp);
-		x |= (long)getc(fp) << 8;
-		x |= (long)getc(fp) << 16;
-		x |= (long)getc(fp) << 24;
-	}
-	else {
-		x = rs_byte(p);
-		x |= (long)rs_byte(p) << 8;
-		x |= (long)rs_byte(p) << 16;
-		x |= (long)rs_byte(p) << 24;
-	}
+    register long x;
+    register FILE *fp = p->fp;
+    if (fp) {
+        x = getc(fp);
+        x |= (long)getc(fp) << 8;
+        x |= (long)getc(fp) << 16;
+        x |= (long)getc(fp) << 24;
+    }
+    else {
+        x = rs_byte(p);
+        x |= (long)rs_byte(p) << 8;
+        x |= (long)rs_byte(p) << 16;
+        x |= (long)rs_byte(p) << 24;
+    }
 #if SIZEOF_LONG > 4
-	/* Sign extension for 64-bit machines */
-	x |= -(x & 0x80000000L);
+    /* Sign extension for 64-bit machines */
+    x |= -(x & 0x80000000L);
 #endif
-	return x;
+    return x;
 }
 
 /* r_long64 deals with the TYPE_INT64 code.  On a machine with
@@ -538,570 +538,570 @@ r_long(RFILE *p)
 static PyObject *
 r_long64(RFILE *p)
 {
-	long lo4 = r_long(p);
-	long hi4 = r_long(p);
+    long lo4 = r_long(p);
+    long hi4 = r_long(p);
 #if SIZEOF_LONG > 4
-	long x = (hi4 << 32) | (lo4 & 0xFFFFFFFFL);
-	return PyInt_FromLong(x);
+    long x = (hi4 << 32) | (lo4 & 0xFFFFFFFFL);
+    return PyInt_FromLong(x);
 #else
-	unsigned char buf[8];
-	int one = 1;
-	int is_little_endian = (int)*(char*)&one;
-	if (is_little_endian) {
-		memcpy(buf, &lo4, 4);
-		memcpy(buf+4, &hi4, 4);
-	}
-	else {
-		memcpy(buf, &hi4, 4);
-		memcpy(buf+4, &lo4, 4);
-	}
-	return _PyLong_FromByteArray(buf, 8, is_little_endian, 1);
+    unsigned char buf[8];
+    int one = 1;
+    int is_little_endian = (int)*(char*)&one;
+    if (is_little_endian) {
+        memcpy(buf, &lo4, 4);
+        memcpy(buf+4, &hi4, 4);
+    }
+    else {
+        memcpy(buf, &hi4, 4);
+        memcpy(buf+4, &lo4, 4);
+    }
+    return _PyLong_FromByteArray(buf, 8, is_little_endian, 1);
 #endif
 }
 
 static PyObject *
 r_PyLong(RFILE *p)
 {
-	PyLongObject *ob;
-	int size, i, j, md, shorts_in_top_digit;
-	long n;
-	digit d;
-
-	n = r_long(p);
-	if (n == 0)
-		return (PyObject *)_PyLong_New(0);
-	if (n < -INT_MAX || n > INT_MAX) {
-		PyErr_SetString(PyExc_ValueError,
-			       "bad marshal data (long size out of range)");
-		return NULL;
-	}
-
-	size = 1 + (ABS(n) - 1) / PyLong_MARSHAL_RATIO;
-	shorts_in_top_digit = 1 + (ABS(n) - 1) % PyLong_MARSHAL_RATIO;
-	ob = _PyLong_New(size);
-	if (ob == NULL)
-		return NULL;
-	Py_SIZE(ob) = n > 0 ? size : -size;
-
-	for (i = 0; i < size-1; i++) {
-		d = 0;
-		for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
-			md = r_short(p);
-			if (md < 0 || md > PyLong_MARSHAL_BASE)
-				goto bad_digit;
-			d += (digit)md << j*PyLong_MARSHAL_SHIFT;
-		}
-		ob->ob_digit[i] = d;
-	}
-	d = 0;
-	for (j=0; j < shorts_in_top_digit; j++) {
-		md = r_short(p);
-		if (md < 0 || md > PyLong_MARSHAL_BASE)
-			goto bad_digit;
-		/* topmost marshal digit should be nonzero */
-		if (md == 0 && j == shorts_in_top_digit - 1) {
-			Py_DECREF(ob);
-			PyErr_SetString(PyExc_ValueError,
-				"bad marshal data (unnormalized long data)");
-			return NULL;
-		}
-		d += (digit)md << j*PyLong_MARSHAL_SHIFT;
-	}
-	/* top digit should be nonzero, else the resulting PyLong won't be
-	   normalized */
-	ob->ob_digit[size-1] = d;
-	return (PyObject *)ob;
+    PyLongObject *ob;
+    int size, i, j, md, shorts_in_top_digit;
+    long n;
+    digit d;
+
+    n = r_long(p);
+    if (n == 0)
+        return (PyObject *)_PyLong_New(0);
+    if (n < -INT_MAX || n > INT_MAX) {
+        PyErr_SetString(PyExc_ValueError,
+                       "bad marshal data (long size out of range)");
+        return NULL;
+    }
+
+    size = 1 + (ABS(n) - 1) / PyLong_MARSHAL_RATIO;
+    shorts_in_top_digit = 1 + (ABS(n) - 1) % PyLong_MARSHAL_RATIO;
+    ob = _PyLong_New(size);
+    if (ob == NULL)
+        return NULL;
+    Py_SIZE(ob) = n > 0 ? size : -size;
+
+    for (i = 0; i < size-1; i++) {
+        d = 0;
+        for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
+            md = r_short(p);
+            if (md < 0 || md > PyLong_MARSHAL_BASE)
+                goto bad_digit;
+            d += (digit)md << j*PyLong_MARSHAL_SHIFT;
+        }
+        ob->ob_digit[i] = d;
+    }
+    d = 0;
+    for (j=0; j < shorts_in_top_digit; j++) {
+        md = r_short(p);
+        if (md < 0 || md > PyLong_MARSHAL_BASE)
+            goto bad_digit;
+        /* topmost marshal digit should be nonzero */
+        if (md == 0 && j == shorts_in_top_digit - 1) {
+            Py_DECREF(ob);
+            PyErr_SetString(PyExc_ValueError,
+                "bad marshal data (unnormalized long data)");
+            return NULL;
+        }
+        d += (digit)md << j*PyLong_MARSHAL_SHIFT;
+    }
+    /* top digit should be nonzero, else the resulting PyLong won't be
+       normalized */
+    ob->ob_digit[size-1] = d;
+    return (PyObject *)ob;
   bad_digit:
-	Py_DECREF(ob);
-	PyErr_SetString(PyExc_ValueError,
-			"bad marshal data (digit out of range in long)");
-	return NULL;
+    Py_DECREF(ob);
+    PyErr_SetString(PyExc_ValueError,
+                    "bad marshal data (digit out of range in long)");
+    return NULL;
 }
 
 
 static PyObject *
 r_object(RFILE *p)
 {
-	/* NULL is a valid return value, it does not necessarily means that
-	   an exception is set. */
-	PyObject *v, *v2;
-	long i, n;
-	int type = r_byte(p);
-	PyObject *retval;
-
-	p->depth++;
-
-	if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
-		p->depth--;
-		PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");
-		return NULL;
-	}
-
-	switch (type) {
-
-	case EOF:
-		PyErr_SetString(PyExc_EOFError,
-				"EOF read where object expected");
-		retval = NULL;
-		break;
-
-	case TYPE_NULL:
-		retval = NULL;
-		break;
-
-	case TYPE_NONE:
-		Py_INCREF(Py_None);
-		retval = Py_None;
-		break;
-
-	case TYPE_STOPITER:
-		Py_INCREF(PyExc_StopIteration);
-		retval = PyExc_StopIteration;
-		break;
-
-	case TYPE_ELLIPSIS:
-		Py_INCREF(Py_Ellipsis);
-		retval = Py_Ellipsis;
-		break;
-
-	case TYPE_FALSE:
-		Py_INCREF(Py_False);
-		retval = Py_False;
-		break;
-
-	case TYPE_TRUE:
-		Py_INCREF(Py_True);
-		retval = Py_True;
-		break;
-
-	case TYPE_INT:
-		retval = PyInt_FromLong(r_long(p));
-		break;
-
-	case TYPE_INT64:
-		retval = r_long64(p);
-		break;
-
-	case TYPE_LONG:
-		retval = r_PyLong(p);
-		break;
-
-	case TYPE_FLOAT:
-		{
-			char buf[256];
-			double dx;
-			n = r_byte(p);
-			if (n == EOF || r_string(buf, (int)n, p) != n) {
-				PyErr_SetString(PyExc_EOFError,
-					"EOF read where object expected");
-				retval = NULL;
-				break;
-			}
-			buf[n] = '\0';
-			dx = PyOS_string_to_double(buf, NULL, NULL);
-			if (dx == -1.0 && PyErr_Occurred()) {
-				retval = NULL;
-				break;
-			}
-			retval = PyFloat_FromDouble(dx);
-			break;
-		}
-
-	case TYPE_BINARY_FLOAT:
-		{
-			unsigned char buf[8];
-			double x;
-			if (r_string((char*)buf, 8, p) != 8) {
-				PyErr_SetString(PyExc_EOFError,
-					"EOF read where object expected");
-				retval = NULL;
-				break;
-			}
-			x = _PyFloat_Unpack8(buf, 1);
-			if (x == -1.0 && PyErr_Occurred()) {
-				retval = NULL;
-				break;
-			}
-			retval = PyFloat_FromDouble(x);
-			break;
-		}
+    /* NULL is a valid return value, it does not necessarily means that
+       an exception is set. */
+    PyObject *v, *v2;
+    long i, n;
+    int type = r_byte(p);
+    PyObject *retval;
+
+    p->depth++;
+
+    if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
+        p->depth--;
+        PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");
+        return NULL;
+    }
+
+    switch (type) {
+
+    case EOF:
+        PyErr_SetString(PyExc_EOFError,
+                        "EOF read where object expected");
+        retval = NULL;
+        break;
+
+    case TYPE_NULL:
+        retval = NULL;
+        break;
+
+    case TYPE_NONE:
+        Py_INCREF(Py_None);
+        retval = Py_None;
+        break;
+
+    case TYPE_STOPITER:
+        Py_INCREF(PyExc_StopIteration);
+        retval = PyExc_StopIteration;
+        break;
+
+    case TYPE_ELLIPSIS:
+        Py_INCREF(Py_Ellipsis);
+        retval = Py_Ellipsis;
+        break;
+
+    case TYPE_FALSE:
+        Py_INCREF(Py_False);
+        retval = Py_False;
+        break;
+
+    case TYPE_TRUE:
+        Py_INCREF(Py_True);
+        retval = Py_True;
+        break;
+
+    case TYPE_INT:
+        retval = PyInt_FromLong(r_long(p));
+        break;
+
+    case TYPE_INT64:
+        retval = r_long64(p);
+        break;
+
+    case TYPE_LONG:
+        retval = r_PyLong(p);
+        break;
+
+    case TYPE_FLOAT:
+        {
+            char buf[256];
+            double dx;
+            n = r_byte(p);
+            if (n == EOF || r_string(buf, (int)n, p) != n) {
+                PyErr_SetString(PyExc_EOFError,
+                    "EOF read where object expected");
+                retval = NULL;
+                break;
+            }
+            buf[n] = '\0';
+            dx = PyOS_string_to_double(buf, NULL, NULL);
+            if (dx == -1.0 && PyErr_Occurred()) {
+                retval = NULL;
+                break;
+            }
+            retval = PyFloat_FromDouble(dx);
+            break;
+        }
+
+    case TYPE_BINARY_FLOAT:
+        {
+            unsigned char buf[8];
+            double x;
+            if (r_string((char*)buf, 8, p) != 8) {
+                PyErr_SetString(PyExc_EOFError,
+                    "EOF read where object expected");
+                retval = NULL;
+                break;
+            }
+            x = _PyFloat_Unpack8(buf, 1);
+            if (x == -1.0 && PyErr_Occurred()) {
+                retval = NULL;
+                break;
+            }
+            retval = PyFloat_FromDouble(x);
+            break;
+        }
 
 #ifndef WITHOUT_COMPLEX
-	case TYPE_COMPLEX:
-		{
-			char buf[256];
-			Py_complex c;
-			n = r_byte(p);
-			if (n == EOF || r_string(buf, (int)n, p) != n) {
-				PyErr_SetString(PyExc_EOFError,
-					"EOF read where object expected");
-				retval = NULL;
-				break;
-			}
-			buf[n] = '\0';
-			c.real = PyOS_string_to_double(buf, NULL, NULL);
-			if (c.real == -1.0 && PyErr_Occurred()) {
-				retval = NULL;
-				break;
-			}
-			n = r_byte(p);
-			if (n == EOF || r_string(buf, (int)n, p) != n) {
-				PyErr_SetString(PyExc_EOFError,
-					"EOF read where object expected");
-				retval = NULL;
-				break;
-			}
-			buf[n] = '\0';
-			c.imag = PyOS_string_to_double(buf, NULL, NULL);
-			if (c.imag == -1.0 && PyErr_Occurred()) {
-				retval = NULL;
-				break;
-			}
-			retval = PyComplex_FromCComplex(c);
-			break;
-		}
-
-	case TYPE_BINARY_COMPLEX:
-		{
-			unsigned char buf[8];
-			Py_complex c;
-			if (r_string((char*)buf, 8, p) != 8) {
-				PyErr_SetString(PyExc_EOFError,
-					"EOF read where object expected");
-				retval = NULL;
-				break;
-			}
-			c.real = _PyFloat_Unpack8(buf, 1);
-			if (c.real == -1.0 && PyErr_Occurred()) {
-				retval = NULL;
-				break;
-			}
-			if (r_string((char*)buf, 8, p) != 8) {
-				PyErr_SetString(PyExc_EOFError,
-					"EOF read where object expected");
-				retval = NULL;
-				break;
-			}
-			c.imag = _PyFloat_Unpack8(buf, 1);
-			if (c.imag == -1.0 && PyErr_Occurred()) {
-				retval = NULL;
-				break;
-			}
-			retval = PyComplex_FromCComplex(c);
-			break;
-		}
+    case TYPE_COMPLEX:
+        {
+            char buf[256];
+            Py_complex c;
+            n = r_byte(p);
+            if (n == EOF || r_string(buf, (int)n, p) != n) {
+                PyErr_SetString(PyExc_EOFError,
+                    "EOF read where object expected");
+                retval = NULL;
+                break;
+            }
+            buf[n] = '\0';
+            c.real = PyOS_string_to_double(buf, NULL, NULL);
+            if (c.real == -1.0 && PyErr_Occurred()) {
+                retval = NULL;
+                break;
+            }
+            n = r_byte(p);
+            if (n == EOF || r_string(buf, (int)n, p) != n) {
+                PyErr_SetString(PyExc_EOFError,
+                    "EOF read where object expected");
+                retval = NULL;
+                break;
+            }
+            buf[n] = '\0';
+            c.imag = PyOS_string_to_double(buf, NULL, NULL);
+            if (c.imag == -1.0 && PyErr_Occurred()) {
+                retval = NULL;
+                break;
+            }
+            retval = PyComplex_FromCComplex(c);
+            break;
+        }
+
+    case TYPE_BINARY_COMPLEX:
+        {
+            unsigned char buf[8];
+            Py_complex c;
+            if (r_string((char*)buf, 8, p) != 8) {
+                PyErr_SetString(PyExc_EOFError,
+                    "EOF read where object expected");
+                retval = NULL;
+                break;
+            }
+            c.real = _PyFloat_Unpack8(buf, 1);
+            if (c.real == -1.0 && PyErr_Occurred()) {
+                retval = NULL;
+                break;
+            }
+            if (r_string((char*)buf, 8, p) != 8) {
+                PyErr_SetString(PyExc_EOFError,
+                    "EOF read where object expected");
+                retval = NULL;
+                break;
+            }
+            c.imag = _PyFloat_Unpack8(buf, 1);
+            if (c.imag == -1.0 && PyErr_Occurred()) {
+                retval = NULL;
+                break;
+            }
+            retval = PyComplex_FromCComplex(c);
+            break;
+        }
 #endif
 
-	case TYPE_INTERNED:
-	case TYPE_STRING:
-		n = r_long(p);
-		if (n < 0 || n > INT_MAX) {
-			PyErr_SetString(PyExc_ValueError, "bad marshal data (string size out of range)");
-			retval = NULL;
-			break;
-		}
-		v = PyString_FromStringAndSize((char *)NULL, n);
-		if (v == NULL) {
-			retval = NULL;
-			break;
-		}
-		if (r_string(PyString_AS_STRING(v), (int)n, p) != n) {
-			Py_DECREF(v);
-			PyErr_SetString(PyExc_EOFError,
-					"EOF read where object expected");
-			retval = NULL;
-			break;
-		}
-		if (type == TYPE_INTERNED) {
-			PyString_InternInPlace(&v);
-			if (PyList_Append(p->strings, v) < 0) {
-				retval = NULL;
-				break;
-			}
-		}
-		retval = v;
-		break;
-
-	case TYPE_STRINGREF:
-		n = r_long(p);
-		if (n < 0 || n >= PyList_GET_SIZE(p->strings)) {
-			PyErr_SetString(PyExc_ValueError, "bad marshal data (string ref out of range)");
-			retval = NULL;
-			break;
-		}
-		v = PyList_GET_ITEM(p->strings, n);
-		Py_INCREF(v);
-		retval = v;
-		break;
+    case TYPE_INTERNED:
+    case TYPE_STRING:
+        n = r_long(p);
+        if (n < 0 || n > INT_MAX) {
+            PyErr_SetString(PyExc_ValueError, "bad marshal data (string size out of range)");
+            retval = NULL;
+            break;
+        }
+        v = PyString_FromStringAndSize((char *)NULL, n);
+        if (v == NULL) {
+            retval = NULL;
+            break;
+        }
+        if (r_string(PyString_AS_STRING(v), (int)n, p) != n) {
+            Py_DECREF(v);
+            PyErr_SetString(PyExc_EOFError,
+                            "EOF read where object expected");
+            retval = NULL;
+            break;
+        }
+        if (type == TYPE_INTERNED) {
+            PyString_InternInPlace(&v);
+            if (PyList_Append(p->strings, v) < 0) {
+                retval = NULL;
+                break;
+            }
+        }
+        retval = v;
+        break;
+
+    case TYPE_STRINGREF:
+        n = r_long(p);
+        if (n < 0 || n >= PyList_GET_SIZE(p->strings)) {
+            PyErr_SetString(PyExc_ValueError, "bad marshal data (string ref out of range)");
+            retval = NULL;
+            break;
+        }
+        v = PyList_GET_ITEM(p->strings, n);
+        Py_INCREF(v);
+        retval = v;
+        break;
 
 #ifdef Py_USING_UNICODE
-	case TYPE_UNICODE:
-	    {
-		char *buffer;
-
-		n = r_long(p);
-		if (n < 0 || n > INT_MAX) {
-			PyErr_SetString(PyExc_ValueError, "bad marshal data (unicode size out of range)");
-			retval = NULL;
-			break;
-		}
-		buffer = PyMem_NEW(char, n);
-		if (buffer == NULL) {
-			retval = PyErr_NoMemory();
-			break;
-		}
-		if (r_string(buffer, (int)n, p) != n) {
-			PyMem_DEL(buffer);
-			PyErr_SetString(PyExc_EOFError,
-				"EOF read where object expected");
-			retval = NULL;
-			break;
-		}
-		v = PyUnicode_DecodeUTF8(buffer, n, NULL);
-		PyMem_DEL(buffer);
-		retval = v;
-		break;
-	    }
+    case TYPE_UNICODE:
+        {
+        char *buffer;
+
+        n = r_long(p);
+        if (n < 0 || n > INT_MAX) {
+            PyErr_SetString(PyExc_ValueError, "bad marshal data (unicode size out of range)");
+            retval = NULL;
+            break;
+        }
+        buffer = PyMem_NEW(char, n);
+        if (buffer == NULL) {
+            retval = PyErr_NoMemory();
+            break;
+        }
+        if (r_string(buffer, (int)n, p) != n) {
+            PyMem_DEL(buffer);
+            PyErr_SetString(PyExc_EOFError,
+                "EOF read where object expected");
+            retval = NULL;
+            break;
+        }
+        v = PyUnicode_DecodeUTF8(buffer, n, NULL);
+        PyMem_DEL(buffer);
+        retval = v;
+        break;
+        }
 #endif
 
-	case TYPE_TUPLE:
-		n = r_long(p);
-		if (n < 0 || n > INT_MAX) {
-			PyErr_SetString(PyExc_ValueError, "bad marshal data (tuple size out of range)");
-			retval = NULL;
-			break;
-		}
-		v = PyTuple_New((int)n);
-		if (v == NULL) {
-			retval = NULL;
-			break;
-		}
-		for (i = 0; i < n; i++) {
-			v2 = r_object(p);
-			if ( v2 == NULL ) {
-				if (!PyErr_Occurred())
-					PyErr_SetString(PyExc_TypeError,
-						"NULL object in marshal data for tuple");
-				Py_DECREF(v);
-				v = NULL;
-				break;
-			}
-			PyTuple_SET_ITEM(v, (int)i, v2);
-		}
-		retval = v;
-		break;
-
-	case TYPE_LIST:
-		n = r_long(p);
-		if (n < 0 || n > INT_MAX) {
-			PyErr_SetString(PyExc_ValueError, "bad marshal data (list size out of range)");
-			retval = NULL;
-			break;
-		}
-		v = PyList_New((int)n);
-		if (v == NULL) {
-			retval = NULL;
-			break;
-		}
-		for (i = 0; i < n; i++) {
-			v2 = r_object(p);
-			if ( v2 == NULL ) {
-				if (!PyErr_Occurred())
-					PyErr_SetString(PyExc_TypeError,
-						"NULL object in marshal data for list");
-				Py_DECREF(v);
-				v = NULL;
-				break;
-			}
-			PyList_SET_ITEM(v, (int)i, v2);
-		}
-		retval = v;
-		break;
-
-	case TYPE_DICT:
-		v = PyDict_New();
-		if (v == NULL) {
-			retval = NULL;
-			break;
-		}
-		for (;;) {
-			PyObject *key, *val;
-			key = r_object(p);
-			if (key == NULL)
-				break;
-			val = r_object(p);
-			if (val != NULL)
-				PyDict_SetItem(v, key, val);
-			Py_DECREF(key);
-			Py_XDECREF(val);
-		}
-		if (PyErr_Occurred()) {
-			Py_DECREF(v);
-			v = NULL;
-		}
-		retval = v;
-		break;
-
-	case TYPE_SET:
-	case TYPE_FROZENSET:
-		n = r_long(p);
-		if (n < 0 || n > INT_MAX) {
-			PyErr_SetString(PyExc_ValueError, "bad marshal data (set size out of range)");
-			retval = NULL;
-			break;
-		}
-                v = (type == TYPE_SET) ? PySet_New(NULL) : PyFrozenSet_New(NULL);
-		if (v == NULL) {
-			retval = NULL;
-			break;
-		}
-		for (i = 0; i < n; i++) {
-			v2 = r_object(p);
-			if ( v2 == NULL ) {
-				if (!PyErr_Occurred())
-					PyErr_SetString(PyExc_TypeError,
-						"NULL object in marshal data for set");
-				Py_DECREF(v);
-				v = NULL;
-				break;
-			}
-			if (PySet_Add(v, v2) == -1) {
-                                Py_DECREF(v);
-                                Py_DECREF(v2);
-                                v = NULL;
-                                break;
-                        }
-                        Py_DECREF(v2);
-		}
-		retval = v;
-		break;
-
-	case TYPE_CODE:
-		if (PyEval_GetRestricted()) {
-			PyErr_SetString(PyExc_RuntimeError,
-				"cannot unmarshal code objects in "
-				"restricted execution mode");
-			retval = NULL;
-			break;
-		}
-		else {
-			int argcount;
-			int nlocals;
-			int stacksize;
-			int flags;
-			PyObject *code = NULL;
-			PyObject *consts = NULL;
-			PyObject *names = NULL;
-			PyObject *varnames = NULL;
-			PyObject *freevars = NULL;
-			PyObject *cellvars = NULL;
-			PyObject *filename = NULL;
-			PyObject *name = NULL;
-			int firstlineno;
-			PyObject *lnotab = NULL;
-			
-			v = NULL;
-
-                        /* XXX ignore long->int overflows for now */
-			argcount = (int)r_long(p);
-			nlocals = (int)r_long(p);
-			stacksize = (int)r_long(p);
-			flags = (int)r_long(p);
-			code = r_object(p);
-			if (code == NULL)
-				goto code_error;
-			consts = r_object(p);
-			if (consts == NULL)
-				goto code_error;
-			names = r_object(p);
-			if (names == NULL)
-				goto code_error;
-			varnames = r_object(p);
-			if (varnames == NULL)
-				goto code_error;
-			freevars = r_object(p);
-			if (freevars == NULL)
-				goto code_error;
-			cellvars = r_object(p);
-			if (cellvars == NULL)
-				goto code_error;
-			filename = r_object(p);
-			if (filename == NULL)
-				goto code_error;
-			name = r_object(p);
-			if (name == NULL)
-				goto code_error;
-			firstlineno = (int)r_long(p);
-			lnotab = r_object(p);
-			if (lnotab == NULL)
-				goto code_error;
-
-			v = (PyObject *) PyCode_New(
-					argcount, nlocals, stacksize, flags,
-					code, consts, names, varnames,
-					freevars, cellvars, filename, name,
-					firstlineno, lnotab);
-
-		  code_error:
-			Py_XDECREF(code);
-			Py_XDECREF(consts);
-			Py_XDECREF(names);
-			Py_XDECREF(varnames);
-			Py_XDECREF(freevars);
-			Py_XDECREF(cellvars);
-			Py_XDECREF(filename);
-			Py_XDECREF(name);
-			Py_XDECREF(lnotab);
-
-		}
-		retval = v;
-		break;
-
-	default:
-		/* Bogus data got written, which isn't ideal.
-		   This will let you keep working and recover. */
-		PyErr_SetString(PyExc_ValueError, "bad marshal data (unknown type code)");
-		retval = NULL;
-		break;
-
-	}
-	p->depth--;
-	return retval;
+    case TYPE_TUPLE:
+        n = r_long(p);
+        if (n < 0 || n > INT_MAX) {
+            PyErr_SetString(PyExc_ValueError, "bad marshal data (tuple size out of range)");
+            retval = NULL;
+            break;
+        }
+        v = PyTuple_New((int)n);
+        if (v == NULL) {
+            retval = NULL;
+            break;
+        }
+        for (i = 0; i < n; i++) {
+            v2 = r_object(p);
+            if ( v2 == NULL ) {
+                if (!PyErr_Occurred())
+                    PyErr_SetString(PyExc_TypeError,
+                        "NULL object in marshal data for tuple");
+                Py_DECREF(v);
+                v = NULL;
+                break;
+            }
+            PyTuple_SET_ITEM(v, (int)i, v2);
+        }
+        retval = v;
+        break;
+
+    case TYPE_LIST:
+        n = r_long(p);
+        if (n < 0 || n > INT_MAX) {
+            PyErr_SetString(PyExc_ValueError, "bad marshal data (list size out of range)");
+            retval = NULL;
+            break;
+        }
+        v = PyList_New((int)n);
+        if (v == NULL) {
+            retval = NULL;
+            break;
+        }
+        for (i = 0; i < n; i++) {
+            v2 = r_object(p);
+            if ( v2 == NULL ) {
+                if (!PyErr_Occurred())
+                    PyErr_SetString(PyExc_TypeError,
+                        "NULL object in marshal data for list");
+                Py_DECREF(v);
+                v = NULL;
+                break;
+            }
+            PyList_SET_ITEM(v, (int)i, v2);
+        }
+        retval = v;
+        break;
+
+    case TYPE_DICT:
+        v = PyDict_New();
+        if (v == NULL) {
+            retval = NULL;
+            break;
+        }
+        for (;;) {
+            PyObject *key, *val;
+            key = r_object(p);
+            if (key == NULL)
+                break;
+            val = r_object(p);
+            if (val != NULL)
+                PyDict_SetItem(v, key, val);
+            Py_DECREF(key);
+            Py_XDECREF(val);
+        }
+        if (PyErr_Occurred()) {
+            Py_DECREF(v);
+            v = NULL;
+        }
+        retval = v;
+        break;
+
+    case TYPE_SET:
+    case TYPE_FROZENSET:
+        n = r_long(p);
+        if (n < 0 || n > INT_MAX) {
+            PyErr_SetString(PyExc_ValueError, "bad marshal data (set size out of range)");
+            retval = NULL;
+            break;
+        }
+        v = (type == TYPE_SET) ? PySet_New(NULL) : PyFrozenSet_New(NULL);
+        if (v == NULL) {
+            retval = NULL;
+            break;
+        }
+        for (i = 0; i < n; i++) {
+            v2 = r_object(p);
+            if ( v2 == NULL ) {
+                if (!PyErr_Occurred())
+                    PyErr_SetString(PyExc_TypeError,
+                        "NULL object in marshal data for set");
+                Py_DECREF(v);
+                v = NULL;
+                break;
+            }
+            if (PySet_Add(v, v2) == -1) {
+                Py_DECREF(v);
+                Py_DECREF(v2);
+                v = NULL;
+                break;
+            }
+            Py_DECREF(v2);
+        }
+        retval = v;
+        break;
+
+    case TYPE_CODE:
+        if (PyEval_GetRestricted()) {
+            PyErr_SetString(PyExc_RuntimeError,
+                "cannot unmarshal code objects in "
+                "restricted execution mode");
+            retval = NULL;
+            break;
+        }
+        else {
+            int argcount;
+            int nlocals;
+            int stacksize;
+            int flags;
+            PyObject *code = NULL;
+            PyObject *consts = NULL;
+            PyObject *names = NULL;
+            PyObject *varnames = NULL;
+            PyObject *freevars = NULL;
+            PyObject *cellvars = NULL;
+            PyObject *filename = NULL;
+            PyObject *name = NULL;
+            int firstlineno;
+            PyObject *lnotab = NULL;
+
+            v = NULL;
+
+            /* XXX ignore long->int overflows for now */
+            argcount = (int)r_long(p);
+            nlocals = (int)r_long(p);
+            stacksize = (int)r_long(p);
+            flags = (int)r_long(p);
+            code = r_object(p);
+            if (code == NULL)
+                goto code_error;
+            consts = r_object(p);
+            if (consts == NULL)
+                goto code_error;
+            names = r_object(p);
+            if (names == NULL)
+                goto code_error;
+            varnames = r_object(p);
+            if (varnames == NULL)
+                goto code_error;
+            freevars = r_object(p);
+            if (freevars == NULL)
+                goto code_error;
+            cellvars = r_object(p);
+            if (cellvars == NULL)
+                goto code_error;
+            filename = r_object(p);
+            if (filename == NULL)
+                goto code_error;
+            name = r_object(p);
+            if (name == NULL)
+                goto code_error;
+            firstlineno = (int)r_long(p);
+            lnotab = r_object(p);
+            if (lnotab == NULL)
+                goto code_error;
+
+            v = (PyObject *) PyCode_New(
+                            argcount, nlocals, stacksize, flags,
+                            code, consts, names, varnames,
+                            freevars, cellvars, filename, name,
+                            firstlineno, lnotab);
+
+          code_error:
+            Py_XDECREF(code);
+            Py_XDECREF(consts);
+            Py_XDECREF(names);
+            Py_XDECREF(varnames);
+            Py_XDECREF(freevars);
+            Py_XDECREF(cellvars);
+            Py_XDECREF(filename);
+            Py_XDECREF(name);
+            Py_XDECREF(lnotab);
+
+        }
+        retval = v;
+        break;
+
+    default:
+        /* Bogus data got written, which isn't ideal.
+           This will let you keep working and recover. */
+        PyErr_SetString(PyExc_ValueError, "bad marshal data (unknown type code)");
+        retval = NULL;
+        break;
+
+    }
+    p->depth--;
+    return retval;
 }
 
 static PyObject *
 read_object(RFILE *p)
 {
-	PyObject *v;
-	if (PyErr_Occurred()) {
-		fprintf(stderr, "XXX readobject called with exception set\n");
-		return NULL;
-	}
-	v = r_object(p);
-	if (v == NULL && !PyErr_Occurred())
-		PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object");
-	return v;
+    PyObject *v;
+    if (PyErr_Occurred()) {
+        fprintf(stderr, "XXX readobject called with exception set\n");
+        return NULL;
+    }
+    v = r_object(p);
+    if (v == NULL && !PyErr_Occurred())
+        PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object");
+    return v;
 }
 
 int
 PyMarshal_ReadShortFromFile(FILE *fp)
 {
-	RFILE rf;
-	assert(fp);
-	rf.fp = fp;
-	rf.strings = NULL;
-	rf.end = rf.ptr = NULL;
-	return r_short(&rf);
+    RFILE rf;
+    assert(fp);
+    rf.fp = fp;
+    rf.strings = NULL;
+    rf.end = rf.ptr = NULL;
+    return r_short(&rf);
 }
 
 long
 PyMarshal_ReadLongFromFile(FILE *fp)
 {
-	RFILE rf;
-	rf.fp = fp;
-	rf.strings = NULL;
-	rf.ptr = rf.end = NULL;
-	return r_long(&rf);
+    RFILE rf;
+    rf.fp = fp;
+    rf.strings = NULL;
+    rf.ptr = rf.end = NULL;
+    return r_long(&rf);
 }
 
 #ifdef HAVE_FSTAT
@@ -1109,11 +1109,11 @@ PyMarshal_ReadLongFromFile(FILE *fp)
 static off_t
 getfilesize(FILE *fp)
 {
-	struct stat st;
-	if (fstat(fileno(fp), &st) != 0)
-		return -1;
-	else
-		return st.st_size;
+    struct stat st;
+    if (fstat(fileno(fp), &st) != 0)
+        return -1;
+    else
+        return st.st_size;
 }
 #endif
 
@@ -1129,27 +1129,27 @@ PyMarshal_ReadLastObjectFromFile(FILE *fp)
 /* REASONABLE_FILE_LIMIT is by defn something big enough for Tkinter.pyc. */
 #define REASONABLE_FILE_LIMIT (1L << 18)
 #ifdef HAVE_FSTAT
-	off_t filesize;
-	filesize = getfilesize(fp);
-	if (filesize > 0 && filesize <= REASONABLE_FILE_LIMIT) {
-		char* pBuf = (char *)PyMem_MALLOC(filesize);
-		if (pBuf != NULL) {
-			PyObject* v;
-			size_t n;
-			/* filesize must fit into an int, because it
-			   is smaller than REASONABLE_FILE_LIMIT */
-			n = fread(pBuf, 1, (int)filesize, fp);
-			v = PyMarshal_ReadObjectFromString(pBuf, n);
-			PyMem_FREE(pBuf);
-			return v;
-		}
-
-	}
+    off_t filesize;
+    filesize = getfilesize(fp);
+    if (filesize > 0 && filesize <= REASONABLE_FILE_LIMIT) {
+        char* pBuf = (char *)PyMem_MALLOC(filesize);
+        if (pBuf != NULL) {
+            PyObject* v;
+            size_t n;
+            /* filesize must fit into an int, because it
+               is smaller than REASONABLE_FILE_LIMIT */
+            n = fread(pBuf, 1, (int)filesize, fp);
+            v = PyMarshal_ReadObjectFromString(pBuf, n);
+            PyMem_FREE(pBuf);
+            return v;
+        }
+
+    }
 #endif
-	/* We don't have fstat, or we do but the file is larger than
-	 * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.
-	 */
-	return PyMarshal_ReadObjectFromFile(fp);
+    /* We don't have fstat, or we do but the file is larger than
+     * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.
+     */
+    return PyMarshal_ReadObjectFromFile(fp);
 
 #undef REASONABLE_FILE_LIMIT
 }
@@ -1157,83 +1157,83 @@ PyMarshal_ReadLastObjectFromFile(FILE *fp)
 PyObject *
 PyMarshal_ReadObjectFromFile(FILE *fp)
 {
-	RFILE rf;
-	PyObject *result;
-	rf.fp = fp;
-	rf.strings = PyList_New(0);
-	rf.depth = 0;
-	rf.ptr = rf.end = NULL;
-	result = r_object(&rf);
-	Py_DECREF(rf.strings);
-	return result;
+    RFILE rf;
+    PyObject *result;
+    rf.fp = fp;
+    rf.strings = PyList_New(0);
+    rf.depth = 0;
+    rf.ptr = rf.end = NULL;
+    result = r_object(&rf);
+    Py_DECREF(rf.strings);
+    return result;
 }
 
 PyObject *
 PyMarshal_ReadObjectFromString(char *str, Py_ssize_t len)
 {
-	RFILE rf;
-	PyObject *result;
-	rf.fp = NULL;
-	rf.ptr = str;
-	rf.end = str + len;
-	rf.strings = PyList_New(0);
-	rf.depth = 0;
-	result = r_object(&rf);
-	Py_DECREF(rf.strings);
-	return result;
+    RFILE rf;
+    PyObject *result;
+    rf.fp = NULL;
+    rf.ptr = str;
+    rf.end = str + len;
+    rf.strings = PyList_New(0);
+    rf.depth = 0;
+    result = r_object(&rf);
+    Py_DECREF(rf.strings);
+    return result;
 }
 
 static void
 set_error(int error)
 {
-	switch (error) {
-	case WFERR_NOMEMORY:
-		PyErr_NoMemory();
-		break;
-	case WFERR_UNMARSHALLABLE:
-		PyErr_SetString(PyExc_ValueError, "unmarshallable object");
-		break;
-	case WFERR_NESTEDTOODEEP:
-	default:
-		PyErr_SetString(PyExc_ValueError,
-			"object too deeply nested to marshal");
-		break;
-	}
+    switch (error) {
+    case WFERR_NOMEMORY:
+        PyErr_NoMemory();
+        break;
+    case WFERR_UNMARSHALLABLE:
+        PyErr_SetString(PyExc_ValueError, "unmarshallable object");
+        break;
+    case WFERR_NESTEDTOODEEP:
+    default:
+        PyErr_SetString(PyExc_ValueError,
+            "object too deeply nested to marshal");
+        break;
+    }
 }
 
 PyObject *
 PyMarshal_WriteObjectToString(PyObject *x, int version)
 {
-	WFILE wf;
-	wf.fp = NULL;
-	wf.str = PyString_FromStringAndSize((char *)NULL, 50);
-	if (wf.str == NULL)
-		return NULL;
-	wf.ptr = PyString_AS_STRING((PyStringObject *)wf.str);
-	wf.end = wf.ptr + PyString_Size(wf.str);
-	wf.error = WFERR_OK;
-	wf.depth = 0;
-	wf.version = version;
-	wf.strings = (version > 0) ? PyDict_New() : NULL;
-	w_object(x, &wf);
-	Py_XDECREF(wf.strings);
-	if (wf.str != NULL) {
-		char *base = PyString_AS_STRING((PyStringObject *)wf.str);
-		if (wf.ptr - base > PY_SSIZE_T_MAX) {
-			Py_DECREF(wf.str);
-			PyErr_SetString(PyExc_OverflowError,
-					"too much marshall data for a string");
-			return NULL;
-		}
-		if (_PyString_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base)))
-			return NULL;
-	}
-	if (wf.error != WFERR_OK) {
-		Py_XDECREF(wf.str);
-		set_error(wf.error);
-		return NULL;
-	}
-	return wf.str;
+    WFILE wf;
+    wf.fp = NULL;
+    wf.str = PyString_FromStringAndSize((char *)NULL, 50);
+    if (wf.str == NULL)
+        return NULL;
+    wf.ptr = PyString_AS_STRING((PyStringObject *)wf.str);
+    wf.end = wf.ptr + PyString_Size(wf.str);
+    wf.error = WFERR_OK;
+    wf.depth = 0;
+    wf.version = version;
+    wf.strings = (version > 0) ? PyDict_New() : NULL;
+    w_object(x, &wf);
+    Py_XDECREF(wf.strings);
+    if (wf.str != NULL) {
+        char *base = PyString_AS_STRING((PyStringObject *)wf.str);
+        if (wf.ptr - base > PY_SSIZE_T_MAX) {
+            Py_DECREF(wf.str);
+            PyErr_SetString(PyExc_OverflowError,
+                            "too much marshall data for a string");
+            return NULL;
+        }
+        if (_PyString_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base)))
+            return NULL;
+    }
+    if (wf.error != WFERR_OK) {
+        Py_XDECREF(wf.str);
+        set_error(wf.error);
+        return NULL;
+    }
+    return wf.str;
 }
 
 /* And an interface for Python programs... */
@@ -1241,32 +1241,32 @@ PyMarshal_WriteObjectToString(PyObject *x, int version)
 static PyObject *
 marshal_dump(PyObject *self, PyObject *args)
 {
-	WFILE wf;
-	PyObject *x;
-	PyObject *f;
-	int version = Py_MARSHAL_VERSION;
-	if (!PyArg_ParseTuple(args, "OO|i:dump", &x, &f, &version))
-		return NULL;
-	if (!PyFile_Check(f)) {
-		PyErr_SetString(PyExc_TypeError,
-				"marshal.dump() 2nd arg must be file");
-		return NULL;
-	}
-	wf.fp = PyFile_AsFile(f);
-	wf.str = NULL;
-	wf.ptr = wf.end = NULL;
-	wf.error = WFERR_OK;
-	wf.depth = 0;
-	wf.strings = (version > 0) ? PyDict_New() : 0;
-	wf.version = version;
-	w_object(x, &wf);
-	Py_XDECREF(wf.strings);
-	if (wf.error != WFERR_OK) {
-		set_error(wf.error);
-		return NULL;
-	}
-	Py_INCREF(Py_None);
-	return Py_None;
+    WFILE wf;
+    PyObject *x;
+    PyObject *f;
+    int version = Py_MARSHAL_VERSION;
+    if (!PyArg_ParseTuple(args, "OO|i:dump", &x, &f, &version))
+        return NULL;
+    if (!PyFile_Check(f)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "marshal.dump() 2nd arg must be file");
+        return NULL;
+    }
+    wf.fp = PyFile_AsFile(f);
+    wf.str = NULL;
+    wf.ptr = wf.end = NULL;
+    wf.error = WFERR_OK;
+    wf.depth = 0;
+    wf.strings = (version > 0) ? PyDict_New() : 0;
+    wf.version = version;
+    w_object(x, &wf);
+    Py_XDECREF(wf.strings);
+    if (wf.error != WFERR_OK) {
+        set_error(wf.error);
+        return NULL;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(dump_doc,
@@ -1286,19 +1286,19 @@ dump should use.");
 static PyObject *
 marshal_load(PyObject *self, PyObject *f)
 {
-	RFILE rf;
-	PyObject *result;
-	if (!PyFile_Check(f)) {
-		PyErr_SetString(PyExc_TypeError,
-				"marshal.load() arg must be file");
-		return NULL;
-	}
-	rf.fp = PyFile_AsFile(f);
-	rf.strings = PyList_New(0);
-	rf.depth = 0;
-	result = read_object(&rf);
-	Py_DECREF(rf.strings);
-	return result;
+    RFILE rf;
+    PyObject *result;
+    if (!PyFile_Check(f)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "marshal.load() arg must be file");
+        return NULL;
+    }
+    rf.fp = PyFile_AsFile(f);
+    rf.strings = PyList_New(0);
+    rf.depth = 0;
+    result = read_object(&rf);
+    Py_DECREF(rf.strings);
+    return result;
 }
 
 PyDoc_STRVAR(load_doc,
@@ -1317,11 +1317,11 @@ dump(), load() will substitute None for the unmarshallable type.");
 static PyObject *
 marshal_dumps(PyObject *self, PyObject *args)
 {
-	PyObject *x;
-	int version = Py_MARSHAL_VERSION;
-	if (!PyArg_ParseTuple(args, "O|i:dumps", &x, &version))
-		return NULL;
-	return PyMarshal_WriteObjectToString(x, version);
+    PyObject *x;
+    int version = Py_MARSHAL_VERSION;
+    if (!PyArg_ParseTuple(args, "O|i:dumps", &x, &version))
+        return NULL;
+    return PyMarshal_WriteObjectToString(x, version);
 }
 
 PyDoc_STRVAR(dumps_doc,
@@ -1338,20 +1338,20 @@ dumps should use.");
 static PyObject *
 marshal_loads(PyObject *self, PyObject *args)
 {
-	RFILE rf;
-	char *s;
-	Py_ssize_t n;
-	PyObject* result;
-	if (!PyArg_ParseTuple(args, "s#:loads", &s, &n))
-		return NULL;
-	rf.fp = NULL;
-	rf.ptr = s;
-	rf.end = s + n;
-	rf.strings = PyList_New(0);
-	rf.depth = 0;
-	result = read_object(&rf);
-	Py_DECREF(rf.strings);
-	return result;
+    RFILE rf;
+    char *s;
+    Py_ssize_t n;
+    PyObject* result;
+    if (!PyArg_ParseTuple(args, "s#:loads", &s, &n))
+        return NULL;
+    rf.fp = NULL;
+    rf.ptr = s;
+    rf.end = s + n;
+    rf.strings = PyList_New(0);
+    rf.depth = 0;
+    result = read_object(&rf);
+    Py_DECREF(rf.strings);
+    return result;
 }
 
 PyDoc_STRVAR(loads_doc,
@@ -1362,11 +1362,11 @@ EOFError, ValueError or TypeError. Extra characters in the string are\n\
 ignored.");
 
 static PyMethodDef marshal_methods[] = {
-	{"dump",	marshal_dump,	METH_VARARGS,	dump_doc},
-	{"load",	marshal_load,	METH_O,		load_doc},
-	{"dumps",	marshal_dumps,	METH_VARARGS,	dumps_doc},
-	{"loads",	marshal_loads,	METH_VARARGS,	loads_doc},
-	{NULL,		NULL}		/* sentinel */
+    {"dump",            marshal_dump,   METH_VARARGS,   dump_doc},
+    {"load",            marshal_load,   METH_O,         load_doc},
+    {"dumps",           marshal_dumps,  METH_VARARGS,   dumps_doc},
+    {"loads",           marshal_loads,  METH_VARARGS,   loads_doc},
+    {NULL,              NULL}           /* sentinel */
 };
 
 PyDoc_STRVAR(marshal_doc,
@@ -1402,9 +1402,9 @@ loads() -- read value from a string");
 PyMODINIT_FUNC
 PyMarshal_Init(void)
 {
-	PyObject *mod = Py_InitModule3("marshal", marshal_methods,
-		marshal_doc);
-	if (mod == NULL)
-		return;
-	PyModule_AddIntConstant(mod, "version", Py_MARSHAL_VERSION);
+    PyObject *mod = Py_InitModule3("marshal", marshal_methods,
+        marshal_doc);
+    if (mod == NULL)
+        return;
+    PyModule_AddIntConstant(mod, "version", Py_MARSHAL_VERSION);
 }
diff --git a/Python/modsupport.c b/Python/modsupport.c
index d54158f..6ee48f3 100644
--- a/Python/modsupport.c
+++ b/Python/modsupport.c
@@ -30,76 +30,76 @@ static char api_version_warning[] =
 
 PyObject *
 Py_InitModule4(const char *name, PyMethodDef *methods, const char *doc,
-	       PyObject *passthrough, int module_api_version)
+               PyObject *passthrough, int module_api_version)
 {
-	PyObject *m, *d, *v, *n;
-	PyMethodDef *ml;
-	if (!Py_IsInitialized())
-	    Py_FatalError("Interpreter not initialized (version mismatch?)");
-	if (module_api_version != PYTHON_API_VERSION) {
-		char message[512];
-		PyOS_snprintf(message, sizeof(message), 
-			      api_version_warning, name, 
-			      PYTHON_API_VERSION, name, 
-			      module_api_version);
-		if (PyErr_Warn(PyExc_RuntimeWarning, message)) 
-			return NULL;
-	}
-	/* Make sure name is fully qualified.
-
-	   This is a bit of a hack: when the shared library is loaded,
-	   the module name is "package.module", but the module calls
-	   Py_InitModule*() with just "module" for the name.  The shared
-	   library loader squirrels away the true name of the module in
-	   _Py_PackageContext, and Py_InitModule*() will substitute this
-	   (if the name actually matches).
-	*/
-	if (_Py_PackageContext != NULL) {
-		char *p = strrchr(_Py_PackageContext, '.');
-		if (p != NULL && strcmp(name, p+1) == 0) {
-			name = _Py_PackageContext;
-			_Py_PackageContext = NULL;
-		}
-	}
-	if ((m = PyImport_AddModule(name)) == NULL)
-		return NULL;
-	d = PyModule_GetDict(m);
-	if (methods != NULL) {
-		n = PyString_FromString(name);
-		if (n == NULL)
-			return NULL;
-		for (ml = methods; ml->ml_name != NULL; ml++) {
-			if ((ml->ml_flags & METH_CLASS) ||
-			    (ml->ml_flags & METH_STATIC)) {
-				PyErr_SetString(PyExc_ValueError,
-						"module functions cannot set"
-						" METH_CLASS or METH_STATIC");
-				Py_DECREF(n);
-				return NULL;
-			}
-			v = PyCFunction_NewEx(ml, passthrough, n);
-			if (v == NULL) {
-				Py_DECREF(n);
-				return NULL;
-			}
-			if (PyDict_SetItemString(d, ml->ml_name, v) != 0) {
-				Py_DECREF(v);
-				Py_DECREF(n);
-				return NULL;
-			}
-			Py_DECREF(v);
-		}
-		Py_DECREF(n);
-	}
-	if (doc != NULL) {
-		v = PyString_FromString(doc);
-		if (v == NULL || PyDict_SetItemString(d, "__doc__", v) != 0) {
-			Py_XDECREF(v);
-			return NULL;
-		}
-		Py_DECREF(v);
-	}
-	return m;
+    PyObject *m, *d, *v, *n;
+    PyMethodDef *ml;
+    if (!Py_IsInitialized())
+        Py_FatalError("Interpreter not initialized (version mismatch?)");
+    if (module_api_version != PYTHON_API_VERSION) {
+        char message[512];
+        PyOS_snprintf(message, sizeof(message),
+                      api_version_warning, name,
+                      PYTHON_API_VERSION, name,
+                      module_api_version);
+        if (PyErr_Warn(PyExc_RuntimeWarning, message))
+            return NULL;
+    }
+    /* Make sure name is fully qualified.
+
+       This is a bit of a hack: when the shared library is loaded,
+       the module name is "package.module", but the module calls
+       Py_InitModule*() with just "module" for the name.  The shared
+       library loader squirrels away the true name of the module in
+       _Py_PackageContext, and Py_InitModule*() will substitute this
+       (if the name actually matches).
+    */
+    if (_Py_PackageContext != NULL) {
+        char *p = strrchr(_Py_PackageContext, '.');
+        if (p != NULL && strcmp(name, p+1) == 0) {
+            name = _Py_PackageContext;
+            _Py_PackageContext = NULL;
+        }
+    }
+    if ((m = PyImport_AddModule(name)) == NULL)
+        return NULL;
+    d = PyModule_GetDict(m);
+    if (methods != NULL) {
+        n = PyString_FromString(name);
+        if (n == NULL)
+            return NULL;
+        for (ml = methods; ml->ml_name != NULL; ml++) {
+            if ((ml->ml_flags & METH_CLASS) ||
+                (ml->ml_flags & METH_STATIC)) {
+                PyErr_SetString(PyExc_ValueError,
+                                "module functions cannot set"
+                                " METH_CLASS or METH_STATIC");
+                Py_DECREF(n);
+                return NULL;
+            }
+            v = PyCFunction_NewEx(ml, passthrough, n);
+            if (v == NULL) {
+                Py_DECREF(n);
+                return NULL;
+            }
+            if (PyDict_SetItemString(d, ml->ml_name, v) != 0) {
+                Py_DECREF(v);
+                Py_DECREF(n);
+                return NULL;
+            }
+            Py_DECREF(v);
+        }
+        Py_DECREF(n);
+    }
+    if (doc != NULL) {
+        v = PyString_FromString(doc);
+        if (v == NULL || PyDict_SetItemString(d, "__doc__", v) != 0) {
+            Py_XDECREF(v);
+            return NULL;
+        }
+        Py_DECREF(v);
+    }
+    return m;
 }
 
 
@@ -108,41 +108,41 @@ Py_InitModule4(const char *name, PyMethodDef *methods, const char *doc,
 static int
 countformat(const char *format, int endchar)
 {
-	int count = 0;
-	int level = 0;
-	while (level > 0 || *format != endchar) {
-		switch (*format) {
-		case '\0':
-			/* Premature end */
-			PyErr_SetString(PyExc_SystemError,
-					"unmatched paren in format");
-			return -1;
-		case '(':
-		case '[':
-		case '{':
-			if (level == 0)
-				count++;
-			level++;
-			break;
-		case ')':
-		case ']':
-		case '}':
-			level--;
-			break;
-		case '#':
-		case '&':
-		case ',':
-		case ':':
-		case ' ':
-		case '\t':
-			break;
-		default:
-			if (level == 0)
-				count++;
-		}
-		format++;
-	}
-	return count;
+    int count = 0;
+    int level = 0;
+    while (level > 0 || *format != endchar) {
+        switch (*format) {
+        case '\0':
+            /* Premature end */
+            PyErr_SetString(PyExc_SystemError,
+                            "unmatched paren in format");
+            return -1;
+        case '(':
+        case '[':
+        case '{':
+            if (level == 0)
+                count++;
+            level++;
+            break;
+        case ')':
+        case ']':
+        case '}':
+            level--;
+            break;
+        case '#':
+        case '&':
+        case ',':
+        case ':':
+        case ' ':
+        case '\t':
+            break;
+        default:
+            if (level == 0)
+                count++;
+        }
+        format++;
+    }
+    return count;
 }
 
 
@@ -158,486 +158,486 @@ static PyObject *do_mkvalue(const char**, va_list *, int);
 static PyObject *
 do_mkdict(const char **p_format, va_list *p_va, int endchar, int n, int flags)
 {
-	PyObject *d;
-	int i;
-	int itemfailed = 0;
-	if (n < 0)
-		return NULL;
-	if ((d = PyDict_New()) == NULL)
-		return NULL;
-	/* Note that we can't bail immediately on error as this will leak
-	   refcounts on any 'N' arguments. */
-	for (i = 0; i < n; i+= 2) {
-		PyObject *k, *v;
-		int err;
-		k = do_mkvalue(p_format, p_va, flags);
-		if (k == NULL) {
-			itemfailed = 1;
-			Py_INCREF(Py_None);
-			k = Py_None;
-		}
-		v = do_mkvalue(p_format, p_va, flags);
-		if (v == NULL) {
-			itemfailed = 1;
-			Py_INCREF(Py_None);
-			v = Py_None;
-		}
-		err = PyDict_SetItem(d, k, v);
-		Py_DECREF(k);
-		Py_DECREF(v);
-		if (err < 0 || itemfailed) {
-			Py_DECREF(d);
-			return NULL;
-		}
-	}
-	if (d != NULL && **p_format != endchar) {
-		Py_DECREF(d);
-		d = NULL;
-		PyErr_SetString(PyExc_SystemError,
-				"Unmatched paren in format");
-	}
-	else if (endchar)
-		++*p_format;
-	return d;
+    PyObject *d;
+    int i;
+    int itemfailed = 0;
+    if (n < 0)
+        return NULL;
+    if ((d = PyDict_New()) == NULL)
+        return NULL;
+    /* Note that we can't bail immediately on error as this will leak
+       refcounts on any 'N' arguments. */
+    for (i = 0; i < n; i+= 2) {
+        PyObject *k, *v;
+        int err;
+        k = do_mkvalue(p_format, p_va, flags);
+        if (k == NULL) {
+            itemfailed = 1;
+            Py_INCREF(Py_None);
+            k = Py_None;
+        }
+        v = do_mkvalue(p_format, p_va, flags);
+        if (v == NULL) {
+            itemfailed = 1;
+            Py_INCREF(Py_None);
+            v = Py_None;
+        }
+        err = PyDict_SetItem(d, k, v);
+        Py_DECREF(k);
+        Py_DECREF(v);
+        if (err < 0 || itemfailed) {
+            Py_DECREF(d);
+            return NULL;
+        }
+    }
+    if (d != NULL && **p_format != endchar) {
+        Py_DECREF(d);
+        d = NULL;
+        PyErr_SetString(PyExc_SystemError,
+                        "Unmatched paren in format");
+    }
+    else if (endchar)
+        ++*p_format;
+    return d;
 }
 
 static PyObject *
 do_mklist(const char **p_format, va_list *p_va, int endchar, int n, int flags)
 {
-	PyObject *v;
-	int i;
-	int itemfailed = 0;
-	if (n < 0)
-		return NULL;
-	v = PyList_New(n);
-	if (v == NULL)
-		return NULL;
-	/* Note that we can't bail immediately on error as this will leak
-	   refcounts on any 'N' arguments. */
-	for (i = 0; i < n; i++) {
-		PyObject *w = do_mkvalue(p_format, p_va, flags);
-		if (w == NULL) {
-			itemfailed = 1;
-			Py_INCREF(Py_None);
-			w = Py_None;
-		}
-		PyList_SET_ITEM(v, i, w);
-	}
-
-	if (itemfailed) {
-		/* do_mkvalue() should have already set an error */
-		Py_DECREF(v);
-		return NULL;
-	}
-	if (**p_format != endchar) {
-		Py_DECREF(v);
-		PyErr_SetString(PyExc_SystemError,
-				"Unmatched paren in format");
-		return NULL;
-	}
-	if (endchar)
-		++*p_format;
-	return v;
+    PyObject *v;
+    int i;
+    int itemfailed = 0;
+    if (n < 0)
+        return NULL;
+    v = PyList_New(n);
+    if (v == NULL)
+        return NULL;
+    /* Note that we can't bail immediately on error as this will leak
+       refcounts on any 'N' arguments. */
+    for (i = 0; i < n; i++) {
+        PyObject *w = do_mkvalue(p_format, p_va, flags);
+        if (w == NULL) {
+            itemfailed = 1;
+            Py_INCREF(Py_None);
+            w = Py_None;
+        }
+        PyList_SET_ITEM(v, i, w);
+    }
+
+    if (itemfailed) {
+        /* do_mkvalue() should have already set an error */
+        Py_DECREF(v);
+        return NULL;
+    }
+    if (**p_format != endchar) {
+        Py_DECREF(v);
+        PyErr_SetString(PyExc_SystemError,
+                        "Unmatched paren in format");
+        return NULL;
+    }
+    if (endchar)
+        ++*p_format;
+    return v;
 }
 
 #ifdef Py_USING_UNICODE
 static int
 _ustrlen(Py_UNICODE *u)
 {
-	int i = 0;
-	Py_UNICODE *v = u;
-	while (*v != 0) { i++; v++; } 
-	return i;
+    int i = 0;
+    Py_UNICODE *v = u;
+    while (*v != 0) { i++; v++; }
+    return i;
 }
 #endif
 
 static PyObject *
 do_mktuple(const char **p_format, va_list *p_va, int endchar, int n, int flags)
 {
-	PyObject *v;
-	int i;
-	int itemfailed = 0;
-	if (n < 0)
-		return NULL;
-	if ((v = PyTuple_New(n)) == NULL)
-		return NULL;
-	/* Note that we can't bail immediately on error as this will leak
-	   refcounts on any 'N' arguments. */
-	for (i = 0; i < n; i++) {
-		PyObject *w = do_mkvalue(p_format, p_va, flags);
-		if (w == NULL) {
-			itemfailed = 1;
-			Py_INCREF(Py_None);
-			w = Py_None;
-		}
-		PyTuple_SET_ITEM(v, i, w);
-	}
-	if (itemfailed) {
-		/* do_mkvalue() should have already set an error */
-		Py_DECREF(v);
-		return NULL;
-	}
-	if (**p_format != endchar) {
-		Py_DECREF(v);
-		PyErr_SetString(PyExc_SystemError,
-				"Unmatched paren in format");
-		return NULL;
-	}
-	if (endchar)
-		++*p_format;
-	return v;
+    PyObject *v;
+    int i;
+    int itemfailed = 0;
+    if (n < 0)
+        return NULL;
+    if ((v = PyTuple_New(n)) == NULL)
+        return NULL;
+    /* Note that we can't bail immediately on error as this will leak
+       refcounts on any 'N' arguments. */
+    for (i = 0; i < n; i++) {
+        PyObject *w = do_mkvalue(p_format, p_va, flags);
+        if (w == NULL) {
+            itemfailed = 1;
+            Py_INCREF(Py_None);
+            w = Py_None;
+        }
+        PyTuple_SET_ITEM(v, i, w);
+    }
+    if (itemfailed) {
+        /* do_mkvalue() should have already set an error */
+        Py_DECREF(v);
+        return NULL;
+    }
+    if (**p_format != endchar) {
+        Py_DECREF(v);
+        PyErr_SetString(PyExc_SystemError,
+                        "Unmatched paren in format");
+        return NULL;
+    }
+    if (endchar)
+        ++*p_format;
+    return v;
 }
 
 static PyObject *
 do_mkvalue(const char **p_format, va_list *p_va, int flags)
 {
-	for (;;) {
-		switch (*(*p_format)++) {
-		case '(':
-			return do_mktuple(p_format, p_va, ')',
-					  countformat(*p_format, ')'), flags);
-
-		case '[':
-			return do_mklist(p_format, p_va, ']',
-					 countformat(*p_format, ']'), flags);
-
-		case '{':
-			return do_mkdict(p_format, p_va, '}',
-					 countformat(*p_format, '}'), flags);
-
-		case 'b':
-		case 'B':
-		case 'h':
-		case 'i':
-			return PyInt_FromLong((long)va_arg(*p_va, int));
-			
-		case 'H':
-			return PyInt_FromLong((long)va_arg(*p_va, unsigned int));
-
-		case 'I':
-		{
-			unsigned int n;
-			n = va_arg(*p_va, unsigned int);
-			if (n > (unsigned long)PyInt_GetMax())
-				return PyLong_FromUnsignedLong((unsigned long)n);
-			else
-				return PyInt_FromLong(n);
-		}
-		
-		case 'n':
+    for (;;) {
+        switch (*(*p_format)++) {
+        case '(':
+            return do_mktuple(p_format, p_va, ')',
+                              countformat(*p_format, ')'), flags);
+
+        case '[':
+            return do_mklist(p_format, p_va, ']',
+                             countformat(*p_format, ']'), flags);
+
+        case '{':
+            return do_mkdict(p_format, p_va, '}',
+                             countformat(*p_format, '}'), flags);
+
+        case 'b':
+        case 'B':
+        case 'h':
+        case 'i':
+            return PyInt_FromLong((long)va_arg(*p_va, int));
+
+        case 'H':
+            return PyInt_FromLong((long)va_arg(*p_va, unsigned int));
+
+        case 'I':
+        {
+            unsigned int n;
+            n = va_arg(*p_va, unsigned int);
+            if (n > (unsigned long)PyInt_GetMax())
+                return PyLong_FromUnsignedLong((unsigned long)n);
+            else
+                return PyInt_FromLong(n);
+        }
+
+        case 'n':
 #if SIZEOF_SIZE_T!=SIZEOF_LONG
-			return PyInt_FromSsize_t(va_arg(*p_va, Py_ssize_t));
+            return PyInt_FromSsize_t(va_arg(*p_va, Py_ssize_t));
 #endif
-			/* Fall through from 'n' to 'l' if Py_ssize_t is long */
-		case 'l':
-			return PyInt_FromLong(va_arg(*p_va, long));
-
-		case 'k':
-		{
-			unsigned long n;
-			n = va_arg(*p_va, unsigned long);
-			if (n > (unsigned long)PyInt_GetMax())
-				return PyLong_FromUnsignedLong(n);
-			else
-				return PyInt_FromLong(n);
-		}
+            /* Fall through from 'n' to 'l' if Py_ssize_t is long */
+        case 'l':
+            return PyInt_FromLong(va_arg(*p_va, long));
+
+        case 'k':
+        {
+            unsigned long n;
+            n = va_arg(*p_va, unsigned long);
+            if (n > (unsigned long)PyInt_GetMax())
+                return PyLong_FromUnsignedLong(n);
+            else
+                return PyInt_FromLong(n);
+        }
 
 #ifdef HAVE_LONG_LONG
-		case 'L':
-			return PyLong_FromLongLong((PY_LONG_LONG)va_arg(*p_va, PY_LONG_LONG));
+        case 'L':
+            return PyLong_FromLongLong((PY_LONG_LONG)va_arg(*p_va, PY_LONG_LONG));
 
-		case 'K':
-			return PyLong_FromUnsignedLongLong((PY_LONG_LONG)va_arg(*p_va, unsigned PY_LONG_LONG));
+        case 'K':
+            return PyLong_FromUnsignedLongLong((PY_LONG_LONG)va_arg(*p_va, unsigned PY_LONG_LONG));
 #endif
 #ifdef Py_USING_UNICODE
-		case 'u':
-		{
-			PyObject *v;
-			Py_UNICODE *u = va_arg(*p_va, Py_UNICODE *);
-			Py_ssize_t n;	
-			if (**p_format == '#') {
-				++*p_format;
-				if (flags & FLAG_SIZE_T)
-					n = va_arg(*p_va, Py_ssize_t);
-				else
-					n = va_arg(*p_va, int);
-			}
-			else
-				n = -1;
-			if (u == NULL) {
-				v = Py_None;
-				Py_INCREF(v);
-			}
-			else {
-				if (n < 0)
-					n = _ustrlen(u);
-				v = PyUnicode_FromUnicode(u, n);
-			}
-			return v;
-		}
+        case 'u':
+        {
+            PyObject *v;
+            Py_UNICODE *u = va_arg(*p_va, Py_UNICODE *);
+            Py_ssize_t n;
+            if (**p_format == '#') {
+                ++*p_format;
+                if (flags & FLAG_SIZE_T)
+                    n = va_arg(*p_va, Py_ssize_t);
+                else
+                    n = va_arg(*p_va, int);
+            }
+            else
+                n = -1;
+            if (u == NULL) {
+                v = Py_None;
+                Py_INCREF(v);
+            }
+            else {
+                if (n < 0)
+                    n = _ustrlen(u);
+                v = PyUnicode_FromUnicode(u, n);
+            }
+            return v;
+        }
 #endif
-		case 'f':
-		case 'd':
-			return PyFloat_FromDouble(
-				(double)va_arg(*p_va, va_double));
+        case 'f':
+        case 'd':
+            return PyFloat_FromDouble(
+                (double)va_arg(*p_va, va_double));
 
 #ifndef WITHOUT_COMPLEX
-		case 'D':
-			return PyComplex_FromCComplex(
-				*((Py_complex *)va_arg(*p_va, Py_complex *)));
+        case 'D':
+            return PyComplex_FromCComplex(
+                *((Py_complex *)va_arg(*p_va, Py_complex *)));
 #endif /* WITHOUT_COMPLEX */
 
-		case 'c':
-		{
-			char p[1];
-			p[0] = (char)va_arg(*p_va, int);
-			return PyString_FromStringAndSize(p, 1);
-		}
-
-		case 's':
-		case 'z':
-		{
-			PyObject *v;
-			char *str = va_arg(*p_va, char *);
-			Py_ssize_t n;
-			if (**p_format == '#') {
-				++*p_format;
-				if (flags & FLAG_SIZE_T)
-					n = va_arg(*p_va, Py_ssize_t);
-				else
-					n = va_arg(*p_va, int);
-			}
-			else
-				n = -1;
-			if (str == NULL) {
-				v = Py_None;
-				Py_INCREF(v);
-			}
-			else {
-				if (n < 0) {
-					size_t m = strlen(str);
-					if (m > PY_SSIZE_T_MAX) {
-						PyErr_SetString(PyExc_OverflowError,
-							"string too long for Python string");
-						return NULL;
-					}
-					n = (Py_ssize_t)m;
-				}
-				v = PyString_FromStringAndSize(str, n);
-			}
-			return v;
-		}
-
-		case 'N':
-		case 'S':
-		case 'O':
-		if (**p_format == '&') {
-			typedef PyObject *(*converter)(void *);
-			converter func = va_arg(*p_va, converter);
-			void *arg = va_arg(*p_va, void *);
-			++*p_format;
-			return (*func)(arg);
-		}
-		else {
-			PyObject *v;
-			v = va_arg(*p_va, PyObject *);
-			if (v != NULL) {
-				if (*(*p_format - 1) != 'N')
-					Py_INCREF(v);
-			}
-			else if (!PyErr_Occurred())
-				/* If a NULL was passed
-				 * because a call that should
-				 * have constructed a value
-				 * failed, that's OK, and we
-				 * pass the error on; but if
-				 * no error occurred it's not
-				 * clear that the caller knew
-				 * what she was doing. */
-				PyErr_SetString(PyExc_SystemError,
-					"NULL object passed to Py_BuildValue");
-			return v;
-		}
-
-		case ':':
-		case ',':
-		case ' ':
-		case '\t':
-			break;
-
-		default:
-			PyErr_SetString(PyExc_SystemError,
-				"bad format char passed to Py_BuildValue");
-			return NULL;
-
-		}
-	}
+        case 'c':
+        {
+            char p[1];
+            p[0] = (char)va_arg(*p_va, int);
+            return PyString_FromStringAndSize(p, 1);
+        }
+
+        case 's':
+        case 'z':
+        {
+            PyObject *v;
+            char *str = va_arg(*p_va, char *);
+            Py_ssize_t n;
+            if (**p_format == '#') {
+                ++*p_format;
+                if (flags & FLAG_SIZE_T)
+                    n = va_arg(*p_va, Py_ssize_t);
+                else
+                    n = va_arg(*p_va, int);
+            }
+            else
+                n = -1;
+            if (str == NULL) {
+                v = Py_None;
+                Py_INCREF(v);
+            }
+            else {
+                if (n < 0) {
+                    size_t m = strlen(str);
+                    if (m > PY_SSIZE_T_MAX) {
+                        PyErr_SetString(PyExc_OverflowError,
+                            "string too long for Python string");
+                        return NULL;
+                    }
+                    n = (Py_ssize_t)m;
+                }
+                v = PyString_FromStringAndSize(str, n);
+            }
+            return v;
+        }
+
+        case 'N':
+        case 'S':
+        case 'O':
+        if (**p_format == '&') {
+            typedef PyObject *(*converter)(void *);
+            converter func = va_arg(*p_va, converter);
+            void *arg = va_arg(*p_va, void *);
+            ++*p_format;
+            return (*func)(arg);
+        }
+        else {
+            PyObject *v;
+            v = va_arg(*p_va, PyObject *);
+            if (v != NULL) {
+                if (*(*p_format - 1) != 'N')
+                    Py_INCREF(v);
+            }
+            else if (!PyErr_Occurred())
+                /* If a NULL was passed
+                 * because a call that should
+                 * have constructed a value
+                 * failed, that's OK, and we
+                 * pass the error on; but if
+                 * no error occurred it's not
+                 * clear that the caller knew
+                 * what she was doing. */
+                PyErr_SetString(PyExc_SystemError,
+                    "NULL object passed to Py_BuildValue");
+            return v;
+        }
+
+        case ':':
+        case ',':
+        case ' ':
+        case '\t':
+            break;
+
+        default:
+            PyErr_SetString(PyExc_SystemError,
+                "bad format char passed to Py_BuildValue");
+            return NULL;
+
+        }
+    }
 }
 
 
 PyObject *
 Py_BuildValue(const char *format, ...)
 {
-	va_list va;
-	PyObject* retval;
-	va_start(va, format);
-	retval = va_build_value(format, va, 0);
-	va_end(va);
-	return retval;
+    va_list va;
+    PyObject* retval;
+    va_start(va, format);
+    retval = va_build_value(format, va, 0);
+    va_end(va);
+    return retval;
 }
 
 PyObject *
 _Py_BuildValue_SizeT(const char *format, ...)
 {
-	va_list va;
-	PyObject* retval;
-	va_start(va, format);
-	retval = va_build_value(format, va, FLAG_SIZE_T);
-	va_end(va);
-	return retval;
+    va_list va;
+    PyObject* retval;
+    va_start(va, format);
+    retval = va_build_value(format, va, FLAG_SIZE_T);
+    va_end(va);
+    return retval;
 }
 
 PyObject *
 Py_VaBuildValue(const char *format, va_list va)
 {
-	return va_build_value(format, va, 0);
+    return va_build_value(format, va, 0);
 }
 
 PyObject *
 _Py_VaBuildValue_SizeT(const char *format, va_list va)
 {
-	return va_build_value(format, va, FLAG_SIZE_T);
+    return va_build_value(format, va, FLAG_SIZE_T);
 }
 
 static PyObject *
 va_build_value(const char *format, va_list va, int flags)
 {
-	const char *f = format;
-	int n = countformat(f, '\0');
-	va_list lva;
+    const char *f = format;
+    int n = countformat(f, '\0');
+    va_list lva;
 
 #ifdef VA_LIST_IS_ARRAY
-	memcpy(lva, va, sizeof(va_list));
+    memcpy(lva, va, sizeof(va_list));
 #else
 #ifdef __va_copy
-	__va_copy(lva, va);
+    __va_copy(lva, va);
 #else
-	lva = va;
+    lva = va;
 #endif
 #endif
 
-	if (n < 0)
-		return NULL;
-	if (n == 0) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	if (n == 1)
-		return do_mkvalue(&f, &lva, flags);
-	return do_mktuple(&f, &lva, '\0', n, flags);
+    if (n < 0)
+        return NULL;
+    if (n == 0) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    if (n == 1)
+        return do_mkvalue(&f, &lva, flags);
+    return do_mktuple(&f, &lva, '\0', n, flags);
 }
 
 
 PyObject *
 PyEval_CallFunction(PyObject *obj, const char *format, ...)
 {
-	va_list vargs;
-	PyObject *args;
-	PyObject *res;
+    va_list vargs;
+    PyObject *args;
+    PyObject *res;
 
-	va_start(vargs, format);
+    va_start(vargs, format);
 
-	args = Py_VaBuildValue(format, vargs);
-	va_end(vargs);
+    args = Py_VaBuildValue(format, vargs);
+    va_end(vargs);
 
-	if (args == NULL)
-		return NULL;
+    if (args == NULL)
+        return NULL;
 
-	res = PyEval_CallObject(obj, args);
-	Py_DECREF(args);
+    res = PyEval_CallObject(obj, args);
+    Py_DECREF(args);
 
-	return res;
+    return res;
 }
 
 
 PyObject *
 PyEval_CallMethod(PyObject *obj, const char *methodname, const char *format, ...)
 {
-	va_list vargs;
-	PyObject *meth;
-	PyObject *args;
-	PyObject *res;
+    va_list vargs;
+    PyObject *meth;
+    PyObject *args;
+    PyObject *res;
 
-	meth = PyObject_GetAttrString(obj, methodname);
-	if (meth == NULL)
-		return NULL;
+    meth = PyObject_GetAttrString(obj, methodname);
+    if (meth == NULL)
+        return NULL;
 
-	va_start(vargs, format);
+    va_start(vargs, format);
 
-	args = Py_VaBuildValue(format, vargs);
-	va_end(vargs);
+    args = Py_VaBuildValue(format, vargs);
+    va_end(vargs);
 
-	if (args == NULL) {
-		Py_DECREF(meth);
-		return NULL;
-	}
+    if (args == NULL) {
+        Py_DECREF(meth);
+        return NULL;
+    }
 
-	res = PyEval_CallObject(meth, args);
-	Py_DECREF(meth);
-	Py_DECREF(args);
+    res = PyEval_CallObject(meth, args);
+    Py_DECREF(meth);
+    Py_DECREF(args);
 
-	return res;
+    return res;
 }
 
 int
 PyModule_AddObject(PyObject *m, const char *name, PyObject *o)
 {
-	PyObject *dict;
-	if (!PyModule_Check(m)) {
-		PyErr_SetString(PyExc_TypeError,
-			    "PyModule_AddObject() needs module as first arg");
-		return -1;
-	}
-	if (!o) {
-		if (!PyErr_Occurred())
-			PyErr_SetString(PyExc_TypeError,
-					"PyModule_AddObject() needs non-NULL value");
-		return -1;
-	}
-
-	dict = PyModule_GetDict(m);
-	if (dict == NULL) {
-		/* Internal error -- modules must have a dict! */
-		PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
-			     PyModule_GetName(m));
-		return -1;
-	}
-	if (PyDict_SetItemString(dict, name, o))
-		return -1;
-	Py_DECREF(o);
-	return 0;
+    PyObject *dict;
+    if (!PyModule_Check(m)) {
+        PyErr_SetString(PyExc_TypeError,
+                    "PyModule_AddObject() needs module as first arg");
+        return -1;
+    }
+    if (!o) {
+        if (!PyErr_Occurred())
+            PyErr_SetString(PyExc_TypeError,
+                            "PyModule_AddObject() needs non-NULL value");
+        return -1;
+    }
+
+    dict = PyModule_GetDict(m);
+    if (dict == NULL) {
+        /* Internal error -- modules must have a dict! */
+        PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
+                     PyModule_GetName(m));
+        return -1;
+    }
+    if (PyDict_SetItemString(dict, name, o))
+        return -1;
+    Py_DECREF(o);
+    return 0;
 }
 
-int 
+int
 PyModule_AddIntConstant(PyObject *m, const char *name, long value)
 {
-	PyObject *o = PyInt_FromLong(value);
-	if (!o)
-		return -1;
-	if (PyModule_AddObject(m, name, o) == 0)
-		return 0;
-	Py_DECREF(o);
-	return -1;
+    PyObject *o = PyInt_FromLong(value);
+    if (!o)
+        return -1;
+    if (PyModule_AddObject(m, name, o) == 0)
+        return 0;
+    Py_DECREF(o);
+    return -1;
 }
 
-int 
+int
 PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
 {
-	PyObject *o = PyString_FromString(value);
-	if (!o)
-		return -1;
-	if (PyModule_AddObject(m, name, o) == 0)
-		return 0;
-	Py_DECREF(o);
-	return -1;
+    PyObject *o = PyString_FromString(value);
+    if (!o)
+        return -1;
+    if (PyModule_AddObject(m, name, o) == 0)
+        return 0;
+    Py_DECREF(o);
+    return -1;
 }
diff --git a/Python/mysnprintf.c b/Python/mysnprintf.c
index 3173863..39e3ff1 100644
--- a/Python/mysnprintf.c
+++ b/Python/mysnprintf.c
@@ -20,20 +20,20 @@
 
    Return value (rv):
 
-	When 0 <= rv < size, the output conversion was unexceptional, and
-	rv characters were written to str (excluding a trailing \0 byte at
-	str[rv]).
+    When 0 <= rv < size, the output conversion was unexceptional, and
+    rv characters were written to str (excluding a trailing \0 byte at
+    str[rv]).
 
-	When rv >= size, output conversion was truncated, and a buffer of
-	size rv+1 would have been needed to avoid truncation.  str[size-1]
-	is \0 in this case.
+    When rv >= size, output conversion was truncated, and a buffer of
+    size rv+1 would have been needed to avoid truncation.  str[size-1]
+    is \0 in this case.
 
-	When rv < 0, "something bad happened".  str[size-1] is \0 in this
-	case too, but the rest of str is unreliable.  It could be that
-	an error in format codes was detected by libc, or on platforms
-	with a non-C99 vsnprintf simply that the buffer wasn't big enough
-	to avoid truncation, or on platforms without any vsnprintf that
-	PyMem_Malloc couldn't obtain space for a temp buffer.
+    When rv < 0, "something bad happened".  str[size-1] is \0 in this
+    case too, but the rest of str is unreliable.  It could be that
+    an error in format codes was detected by libc, or on platforms
+    with a non-C99 vsnprintf simply that the buffer wasn't big enough
+    to avoid truncation, or on platforms without any vsnprintf that
+    PyMem_Malloc couldn't obtain space for a temp buffer.
 
    CAUTION:  Unlike C99, str != NULL and size > 0 are required.
 */
@@ -41,65 +41,65 @@
 int
 PyOS_snprintf(char *str, size_t size, const  char  *format, ...)
 {
-	int rc;
-	va_list va;
+    int rc;
+    va_list va;
 
-	va_start(va, format);
-	rc = PyOS_vsnprintf(str, size, format, va);
-	va_end(va);
-	return rc;
+    va_start(va, format);
+    rc = PyOS_vsnprintf(str, size, format, va);
+    va_end(va);
+    return rc;
 }
 
 int
 PyOS_vsnprintf(char *str, size_t size, const char  *format, va_list va)
 {
-	int len;  /* # bytes written, excluding \0 */
+    int len;  /* # bytes written, excluding \0 */
 #ifdef HAVE_SNPRINTF
 #define _PyOS_vsnprintf_EXTRA_SPACE 1
 #else
 #define _PyOS_vsnprintf_EXTRA_SPACE 512
-	char *buffer;
+    char *buffer;
 #endif
-	assert(str != NULL);
-	assert(size > 0);
-	assert(format != NULL);
-	/* We take a size_t as input but return an int.  Sanity check
-	 * our input so that it won't cause an overflow in the
-         * vsnprintf return value or the buffer malloc size.  */
-	if (size > INT_MAX - _PyOS_vsnprintf_EXTRA_SPACE) {
-		len = -666;
-		goto Done;
-	}
+    assert(str != NULL);
+    assert(size > 0);
+    assert(format != NULL);
+    /* We take a size_t as input but return an int.  Sanity check
+     * our input so that it won't cause an overflow in the
+     * vsnprintf return value or the buffer malloc size.  */
+    if (size > INT_MAX - _PyOS_vsnprintf_EXTRA_SPACE) {
+        len = -666;
+        goto Done;
+    }
 
 #ifdef HAVE_SNPRINTF
-	len = vsnprintf(str, size, format, va);
+    len = vsnprintf(str, size, format, va);
 #else
-	/* Emulate it. */
-	buffer = PyMem_MALLOC(size + _PyOS_vsnprintf_EXTRA_SPACE);
-	if (buffer == NULL) {
-		len = -666;
-		goto Done;
-	}
-
-	len = vsprintf(buffer, format, va);
-	if (len < 0)
-		/* ignore the error */;
-
-	else if ((size_t)len >= size + _PyOS_vsnprintf_EXTRA_SPACE)
-		Py_FatalError("Buffer overflow in PyOS_snprintf/PyOS_vsnprintf");
-
-	else {
-		const size_t to_copy = (size_t)len < size ?
-					(size_t)len : size - 1;
-		assert(to_copy < size);
-		memcpy(str, buffer, to_copy);
-		str[to_copy] = '\0';
-	}
-	PyMem_FREE(buffer);
+    /* Emulate it. */
+    buffer = PyMem_MALLOC(size + _PyOS_vsnprintf_EXTRA_SPACE);
+    if (buffer == NULL) {
+        len = -666;
+        goto Done;
+    }
+
+    len = vsprintf(buffer, format, va);
+    if (len < 0)
+        /* ignore the error */;
+
+    else if ((size_t)len >= size + _PyOS_vsnprintf_EXTRA_SPACE)
+        Py_FatalError("Buffer overflow in PyOS_snprintf/PyOS_vsnprintf");
+
+    else {
+        const size_t to_copy = (size_t)len < size ?
+                                (size_t)len : size - 1;
+        assert(to_copy < size);
+        memcpy(str, buffer, to_copy);
+        str[to_copy] = '\0';
+    }
+    PyMem_FREE(buffer);
 #endif
 Done:
-	if (size > 0)
-		str[size-1] = '\0';
-	return len;
+    if (size > 0)
+        str[size-1] = '\0';
+    return len;
 #undef _PyOS_vsnprintf_EXTRA_SPACE
 }
diff --git a/Python/mystrtoul.c b/Python/mystrtoul.c
index ebd468c..c35be81 100644
--- a/Python/mystrtoul.c
+++ b/Python/mystrtoul.c
@@ -18,43 +18,43 @@
  * i * base doesn't overflow unsigned long.
  */
 static unsigned long smallmax[] = {
-	0, /* bases 0 and 1 are invalid */
-	0,
-	ULONG_MAX / 2,
-	ULONG_MAX / 3,
-	ULONG_MAX / 4,
-	ULONG_MAX / 5,
-	ULONG_MAX / 6,
-	ULONG_MAX / 7,
-	ULONG_MAX / 8,
-	ULONG_MAX / 9,
-	ULONG_MAX / 10,
-	ULONG_MAX / 11,
-	ULONG_MAX / 12,
-	ULONG_MAX / 13,
-	ULONG_MAX / 14,
-	ULONG_MAX / 15,
-	ULONG_MAX / 16,
-	ULONG_MAX / 17,
-	ULONG_MAX / 18,
-	ULONG_MAX / 19,
-	ULONG_MAX / 20,
-	ULONG_MAX / 21,
-	ULONG_MAX / 22,
-	ULONG_MAX / 23,
-	ULONG_MAX / 24,
-	ULONG_MAX / 25,
-	ULONG_MAX / 26,
-	ULONG_MAX / 27,
-	ULONG_MAX / 28,
-	ULONG_MAX / 29,
-	ULONG_MAX / 30,
-	ULONG_MAX / 31,
-	ULONG_MAX / 32,
-	ULONG_MAX / 33,
-	ULONG_MAX / 34,
-	ULONG_MAX / 35,
-	ULONG_MAX / 36,
+    0, /* bases 0 and 1 are invalid */
+    0,
+    ULONG_MAX / 2,
+    ULONG_MAX / 3,
+    ULONG_MAX / 4,
+    ULONG_MAX / 5,
+    ULONG_MAX / 6,
+    ULONG_MAX / 7,
+    ULONG_MAX / 8,
+    ULONG_MAX / 9,
+    ULONG_MAX / 10,
+    ULONG_MAX / 11,
+    ULONG_MAX / 12,
+    ULONG_MAX / 13,
+    ULONG_MAX / 14,
+    ULONG_MAX / 15,
+    ULONG_MAX / 16,
+    ULONG_MAX / 17,
+    ULONG_MAX / 18,
+    ULONG_MAX / 19,
+    ULONG_MAX / 20,
+    ULONG_MAX / 21,
+    ULONG_MAX / 22,
+    ULONG_MAX / 23,
+    ULONG_MAX / 24,
+    ULONG_MAX / 25,
+    ULONG_MAX / 26,
+    ULONG_MAX / 27,
+    ULONG_MAX / 28,
+    ULONG_MAX / 29,
+    ULONG_MAX / 30,
+    ULONG_MAX / 31,
+    ULONG_MAX / 32,
+    ULONG_MAX / 33,
+    ULONG_MAX / 34,
+    ULONG_MAX / 35,
+    ULONG_MAX / 36,
 };
 
 /* maximum digits that can't ever overflow for bases 2 through 36,
@@ -63,223 +63,223 @@ static unsigned long smallmax[] = {
  */
 #if SIZEOF_LONG == 4
 static int digitlimit[] = {
-	0,  0, 32, 20, 16, 13, 12, 11, 10, 10,  /*  0 -  9 */
-	9,  9,  8,  8,  8,  8,  8,  7,  7,  7,  /* 10 - 19 */
-	7,  7,  7,  7,  6,  6,  6,  6,  6,  6,  /* 20 - 29 */
-	6,  6,  6,  6,  6,  6,  6};             /* 30 - 36 */
+    0,  0, 32, 20, 16, 13, 12, 11, 10, 10,  /*  0 -  9 */
+    9,  9,  8,  8,  8,  8,  8,  7,  7,  7,  /* 10 - 19 */
+    7,  7,  7,  7,  6,  6,  6,  6,  6,  6,  /* 20 - 29 */
+    6,  6,  6,  6,  6,  6,  6};             /* 30 - 36 */
 #elif SIZEOF_LONG == 8
 /* [int(math.floor(math.log(2**64, i))) for i in range(2, 37)] */
 static int digitlimit[] = {
-	 0,   0, 64, 40, 32, 27, 24, 22, 21, 20,  /*  0 -  9 */
-	19,  18, 17, 17, 16, 16, 16, 15, 15, 15,  /* 10 - 19 */
-	14,  14, 14, 14, 13, 13, 13, 13, 13, 13,  /* 20 - 29 */
-	13,  12, 12, 12, 12, 12, 12};             /* 30 - 36 */
+         0,   0, 64, 40, 32, 27, 24, 22, 21, 20,  /*  0 -  9 */
+    19,  18, 17, 17, 16, 16, 16, 15, 15, 15,  /* 10 - 19 */
+    14,  14, 14, 14, 13, 13, 13, 13, 13, 13,  /* 20 - 29 */
+    13,  12, 12, 12, 12, 12, 12};             /* 30 - 36 */
 #else
 #error "Need table for SIZEOF_LONG"
 #endif
 
 /*
-**	strtoul
-**		This is a general purpose routine for converting
-**		an ascii string to an integer in an arbitrary base.
-**		Leading white space is ignored.  If 'base' is zero
-**		it looks for a leading 0, 0b, 0B, 0o, 0O, 0x or 0X
-**		to tell which base.  If these are absent it defaults
-**		to 10. Base must be 0 or between 2 and 36 (inclusive).
-**		If 'ptr' is non-NULL it will contain a pointer to
-**		the end of the scan.
-**		Errors due to bad pointers will probably result in
-**		exceptions - we don't check for them.
+**      strtoul
+**              This is a general purpose routine for converting
+**              an ascii string to an integer in an arbitrary base.
+**              Leading white space is ignored.  If 'base' is zero
+**              it looks for a leading 0, 0b, 0B, 0o, 0O, 0x or 0X
+**              to tell which base.  If these are absent it defaults
+**              to 10. Base must be 0 or between 2 and 36 (inclusive).
+**              If 'ptr' is non-NULL it will contain a pointer to
+**              the end of the scan.
+**              Errors due to bad pointers will probably result in
+**              exceptions - we don't check for them.
 */
 unsigned long
 PyOS_strtoul(register char *str, char **ptr, int base)
 {
-	register unsigned long result = 0; /* return value of the function */
-	register int c;	 	/* current input character */
-	register int ovlimit; 	/* required digits to overflow */
-
-	/* skip leading white space */
-	while (*str && isspace(Py_CHARMASK(*str)))
-		++str;
-
-	/* check for leading 0 or 0x for auto-base or base 16 */
-	switch (base) {
-	case 0:		/* look for leading 0, 0b, 0o or 0x */
-		if (*str == '0') {
-			++str;
-			if (*str == 'x' || *str == 'X') {
-				/* there must be at least one digit after 0x */
-				if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 16) {
-					if (ptr)
-						*ptr = str;
-					return 0;
-				}
-				++str;
-				base = 16;
-			} else if (*str == 'o' || *str == 'O') {
-				/* there must be at least one digit after 0o */
-				if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 8) {
-					if (ptr)
-						*ptr = str;
-					return 0;
-				}
-				++str;
-				base = 8;
-			} else if (*str == 'b' || *str == 'B') {
-				/* there must be at least one digit after 0b */
-				if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 2) {
-					if (ptr)
-						*ptr = str;
-					return 0;
-				}
-				++str;
-				base = 2;
-			} else {
-				base = 8;
-			}
-		}
-		else
-			base = 10;
-		break;
-
-	case 2:	/* skip leading 0b or 0B */
-		if (*str == '0') {
-			++str;
-			if (*str == 'b' || *str == 'B') {
-				/* there must be at least one digit after 0b */
-				if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 2) {
-					if (ptr)
-						*ptr = str;
-					return 0;
-				}
-				++str;
-			}
-		}
-		break;
-
-	case 8:	/* skip leading 0o or 0O */
-		if (*str == '0') {
-			++str;
-			if (*str == 'o' || *str == 'O') {
-				/* there must be at least one digit after 0o */
-				if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 8) {
-					if (ptr)
-						*ptr = str;
-					return 0;
-				}
-				++str;
-			}
-		}
-		break;
-
-	case 16:	/* skip leading 0x or 0X */
-		if (*str == '0') {
-			++str;
-			if (*str == 'x' || *str == 'X') {
-				/* there must be at least one digit after 0x */
-				if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 16) {
-					if (ptr)
-						*ptr = str;
-					return 0;
-				}
-				++str;
-			}
-		}
-		break;
-	}
-
-	/* catch silly bases */
-	if (base < 2 || base > 36) {
-		if (ptr)
-			*ptr = str;
-		return 0;
-	}
-
-	/* skip leading zeroes */
-	while (*str == '0')
-		++str;
-
-	/* base is guaranteed to be in [2, 36] at this point */
-	ovlimit = digitlimit[base];
-
-	/* do the conversion until non-digit character encountered */
-	while ((c = _PyLong_DigitValue[Py_CHARMASK(*str)]) < base) {
-		if (ovlimit > 0) /* no overflow check required */
-			result = result * base + c;
-		else { /* requires overflow check */
-			register unsigned long temp_result;
-
-			if (ovlimit < 0) /* guaranteed overflow */
-				goto overflowed;
-
-			/* there could be an overflow */
-			/* check overflow just from shifting */
-			if (result > smallmax[base])
-				goto overflowed;
-
-			result *= base;
-
-			/* check overflow from the digit's value */
-			temp_result = result + c;
-			if (temp_result < result)
-				goto overflowed;
-
-			result = temp_result;
-		}
-
-		++str;
-		--ovlimit;
-	}
-
-	/* set pointer to point to the last character scanned */
-	if (ptr)
-		*ptr = str;
-
-	return result;
+    register unsigned long result = 0; /* return value of the function */
+    register int c;             /* current input character */
+    register int ovlimit;       /* required digits to overflow */
+
+    /* skip leading white space */
+    while (*str && isspace(Py_CHARMASK(*str)))
+        ++str;
+
+    /* check for leading 0 or 0x for auto-base or base 16 */
+    switch (base) {
+    case 0:             /* look for leading 0, 0b, 0o or 0x */
+        if (*str == '0') {
+            ++str;
+            if (*str == 'x' || *str == 'X') {
+                /* there must be at least one digit after 0x */
+                if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 16) {
+                    if (ptr)
+                        *ptr = str;
+                    return 0;
+                }
+                ++str;
+                base = 16;
+            } else if (*str == 'o' || *str == 'O') {
+                /* there must be at least one digit after 0o */
+                if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 8) {
+                    if (ptr)
+                        *ptr = str;
+                    return 0;
+                }
+                ++str;
+                base = 8;
+            } else if (*str == 'b' || *str == 'B') {
+                /* there must be at least one digit after 0b */
+                if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 2) {
+                    if (ptr)
+                        *ptr = str;
+                    return 0;
+                }
+                ++str;
+                base = 2;
+            } else {
+                base = 8;
+            }
+        }
+        else
+            base = 10;
+        break;
+
+    case 2:     /* skip leading 0b or 0B */
+        if (*str == '0') {
+            ++str;
+            if (*str == 'b' || *str == 'B') {
+                /* there must be at least one digit after 0b */
+                if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 2) {
+                    if (ptr)
+                        *ptr = str;
+                    return 0;
+                }
+                ++str;
+            }
+        }
+        break;
+
+    case 8:     /* skip leading 0o or 0O */
+        if (*str == '0') {
+            ++str;
+            if (*str == 'o' || *str == 'O') {
+                /* there must be at least one digit after 0o */
+                if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 8) {
+                    if (ptr)
+                        *ptr = str;
+                    return 0;
+                }
+                ++str;
+            }
+        }
+        break;
+
+    case 16:            /* skip leading 0x or 0X */
+        if (*str == '0') {
+            ++str;
+            if (*str == 'x' || *str == 'X') {
+                /* there must be at least one digit after 0x */
+                if (_PyLong_DigitValue[Py_CHARMASK(str[1])] >= 16) {
+                    if (ptr)
+                        *ptr = str;
+                    return 0;
+                }
+                ++str;
+            }
+        }
+        break;
+    }
+
+    /* catch silly bases */
+    if (base < 2 || base > 36) {
+        if (ptr)
+            *ptr = str;
+        return 0;
+    }
+
+    /* skip leading zeroes */
+    while (*str == '0')
+        ++str;
+
+    /* base is guaranteed to be in [2, 36] at this point */
+    ovlimit = digitlimit[base];
+
+    /* do the conversion until non-digit character encountered */
+    while ((c = _PyLong_DigitValue[Py_CHARMASK(*str)]) < base) {
+        if (ovlimit > 0) /* no overflow check required */
+            result = result * base + c;
+        else { /* requires overflow check */
+            register unsigned long temp_result;
+
+            if (ovlimit < 0) /* guaranteed overflow */
+                goto overflowed;
+
+            /* there could be an overflow */
+            /* check overflow just from shifting */
+            if (result > smallmax[base])
+                goto overflowed;
+
+            result *= base;
+
+            /* check overflow from the digit's value */
+            temp_result = result + c;
+            if (temp_result < result)
+                goto overflowed;
+
+            result = temp_result;
+        }
+
+        ++str;
+        --ovlimit;
+    }
+
+    /* set pointer to point to the last character scanned */
+    if (ptr)
+        *ptr = str;
+
+    return result;
 
 overflowed:
-	if (ptr) {
-		/* spool through remaining digit characters */
-		while (_PyLong_DigitValue[Py_CHARMASK(*str)] < base)
-			++str;
-		*ptr = str;
-	}
-	errno = ERANGE;
-	return (unsigned long)-1;
+    if (ptr) {
+        /* spool through remaining digit characters */
+        while (_PyLong_DigitValue[Py_CHARMASK(*str)] < base)
+            ++str;
+        *ptr = str;
+    }
+    errno = ERANGE;
+    return (unsigned long)-1;
 }
 
 /* Checking for overflow in PyOS_strtol is a PITA; see comments
  * about PY_ABS_LONG_MIN in longobject.c.
  */
-#define PY_ABS_LONG_MIN		(0-(unsigned long)LONG_MIN)
+#define PY_ABS_LONG_MIN         (0-(unsigned long)LONG_MIN)
 
 long
 PyOS_strtol(char *str, char **ptr, int base)
 {
-	long result;
-	unsigned long uresult;
-	char sign;
-
-	while (*str && isspace(Py_CHARMASK(*str)))
-		str++;
-
-	sign = *str;
-	if (sign == '+' || sign == '-')
-		str++;
-
-	uresult = PyOS_strtoul(str, ptr, base);
-
-	if (uresult <= (unsigned long)LONG_MAX) {
-		result = (long)uresult;
-		if (sign == '-')
-			result = -result;
-	}
-	else if (sign == '-' && uresult == PY_ABS_LONG_MIN) {
-		result = LONG_MIN;
-	}
-	else {
-		errno = ERANGE;
-		result = LONG_MAX;
-	}
-	return result;
+    long result;
+    unsigned long uresult;
+    char sign;
+
+    while (*str && isspace(Py_CHARMASK(*str)))
+        str++;
+
+    sign = *str;
+    if (sign == '+' || sign == '-')
+        str++;
+
+    uresult = PyOS_strtoul(str, ptr, base);
+
+    if (uresult <= (unsigned long)LONG_MAX) {
+        result = (long)uresult;
+        if (sign == '-')
+            result = -result;
+    }
+    else if (sign == '-' && uresult == PY_ABS_LONG_MIN) {
+        result = LONG_MIN;
+    }
+    else {
+        errno = ERANGE;
+        result = LONG_MAX;
+    }
+    return result;
 }
diff --git a/Python/peephole.c b/Python/peephole.c
index fbc81ff..313eb43 100644
--- a/Python/peephole.c
+++ b/Python/peephole.c
@@ -12,651 +12,651 @@
 #include "opcode.h"
 
 #define GETARG(arr, i) ((int)((arr[i+2]<<8) + arr[i+1]))
-#define UNCONDITIONAL_JUMP(op)	(op==JUMP_ABSOLUTE || op==JUMP_FORWARD)
+#define UNCONDITIONAL_JUMP(op)  (op==JUMP_ABSOLUTE || op==JUMP_FORWARD)
 #define CONDITIONAL_JUMP(op) (op==POP_JUMP_IF_FALSE || op==POP_JUMP_IF_TRUE \
-	|| op==JUMP_IF_FALSE_OR_POP || op==JUMP_IF_TRUE_OR_POP)
+    || op==JUMP_IF_FALSE_OR_POP || op==JUMP_IF_TRUE_OR_POP)
 #define ABSOLUTE_JUMP(op) (op==JUMP_ABSOLUTE || op==CONTINUE_LOOP \
-	|| op==POP_JUMP_IF_FALSE || op==POP_JUMP_IF_TRUE \
-	|| op==JUMP_IF_FALSE_OR_POP || op==JUMP_IF_TRUE_OR_POP)
+    || op==POP_JUMP_IF_FALSE || op==POP_JUMP_IF_TRUE \
+    || op==JUMP_IF_FALSE_OR_POP || op==JUMP_IF_TRUE_OR_POP)
 #define JUMPS_ON_TRUE(op) (op==POP_JUMP_IF_TRUE || op==JUMP_IF_TRUE_OR_POP)
 #define GETJUMPTGT(arr, i) (GETARG(arr,i) + (ABSOLUTE_JUMP(arr[i]) ? 0 : i+3))
 #define SETARG(arr, i, val) arr[i+2] = val>>8; arr[i+1] = val & 255
 #define CODESIZE(op)  (HAS_ARG(op) ? 3 : 1)
 #define ISBASICBLOCK(blocks, start, bytes) \
-	(blocks[start]==blocks[start+bytes-1])
+    (blocks[start]==blocks[start+bytes-1])
 
 /* Replace LOAD_CONST c1. LOAD_CONST c2 ... LOAD_CONST cn BUILD_TUPLE n
-   with	   LOAD_CONST (c1, c2, ... cn).
+   with    LOAD_CONST (c1, c2, ... cn).
    The consts table must still be in list form so that the
    new constant (c1, c2, ... cn) can be appended.
    Called with codestr pointing to the first LOAD_CONST.
-   Bails out with no change if one or more of the LOAD_CONSTs is missing. 
+   Bails out with no change if one or more of the LOAD_CONSTs is missing.
    Also works for BUILD_LIST when followed by an "in" or "not in" test.
 */
 static int
 tuple_of_constants(unsigned char *codestr, Py_ssize_t n, PyObject *consts)
 {
-	PyObject *newconst, *constant;
-	Py_ssize_t i, arg, len_consts;
-
-	/* Pre-conditions */
-	assert(PyList_CheckExact(consts));
-	assert(codestr[n*3] == BUILD_TUPLE || codestr[n*3] == BUILD_LIST);
-	assert(GETARG(codestr, (n*3)) == n);
-	for (i=0 ; i<n ; i++)
-		assert(codestr[i*3] == LOAD_CONST);
-
-	/* Buildup new tuple of constants */
-	newconst = PyTuple_New(n);
-	if (newconst == NULL)
-		return 0;
-	len_consts = PyList_GET_SIZE(consts);
-	for (i=0 ; i<n ; i++) {
-		arg = GETARG(codestr, (i*3));
-		assert(arg < len_consts);
-		constant = PyList_GET_ITEM(consts, arg);
-		Py_INCREF(constant);
-		PyTuple_SET_ITEM(newconst, i, constant);
-	}
-
-	/* Append folded constant onto consts */
-	if (PyList_Append(consts, newconst)) {
-		Py_DECREF(newconst);
-		return 0;
-	}
-	Py_DECREF(newconst);
-
-	/* Write NOPs over old LOAD_CONSTS and
-	   add a new LOAD_CONST newconst on top of the BUILD_TUPLE n */
-	memset(codestr, NOP, n*3);
-	codestr[n*3] = LOAD_CONST;
-	SETARG(codestr, (n*3), len_consts);
-	return 1;
+    PyObject *newconst, *constant;
+    Py_ssize_t i, arg, len_consts;
+
+    /* Pre-conditions */
+    assert(PyList_CheckExact(consts));
+    assert(codestr[n*3] == BUILD_TUPLE || codestr[n*3] == BUILD_LIST);
+    assert(GETARG(codestr, (n*3)) == n);
+    for (i=0 ; i<n ; i++)
+        assert(codestr[i*3] == LOAD_CONST);
+
+    /* Buildup new tuple of constants */
+    newconst = PyTuple_New(n);
+    if (newconst == NULL)
+        return 0;
+    len_consts = PyList_GET_SIZE(consts);
+    for (i=0 ; i<n ; i++) {
+        arg = GETARG(codestr, (i*3));
+        assert(arg < len_consts);
+        constant = PyList_GET_ITEM(consts, arg);
+        Py_INCREF(constant);
+        PyTuple_SET_ITEM(newconst, i, constant);
+    }
+
+    /* Append folded constant onto consts */
+    if (PyList_Append(consts, newconst)) {
+        Py_DECREF(newconst);
+        return 0;
+    }
+    Py_DECREF(newconst);
+
+    /* Write NOPs over old LOAD_CONSTS and
+       add a new LOAD_CONST newconst on top of the BUILD_TUPLE n */
+    memset(codestr, NOP, n*3);
+    codestr[n*3] = LOAD_CONST;
+    SETARG(codestr, (n*3), len_consts);
+    return 1;
 }
 
 /* Replace LOAD_CONST c1. LOAD_CONST c2 BINOP
-   with	   LOAD_CONST binop(c1,c2)
+   with    LOAD_CONST binop(c1,c2)
    The consts table must still be in list form so that the
    new constant can be appended.
-   Called with codestr pointing to the first LOAD_CONST. 
-   Abandons the transformation if the folding fails (i.e.  1+'a').  
+   Called with codestr pointing to the first LOAD_CONST.
+   Abandons the transformation if the folding fails (i.e.  1+'a').
    If the new constant is a sequence, only folds when the size
-   is below a threshold value.	That keeps pyc files from
-   becoming large in the presence of code like:	 (None,)*1000.
+   is below a threshold value.  That keeps pyc files from
+   becoming large in the presence of code like:  (None,)*1000.
 */
 static int
 fold_binops_on_constants(unsigned char *codestr, PyObject *consts)
 {
-	PyObject *newconst, *v, *w;
-	Py_ssize_t len_consts, size;
-	int opcode;
-
-	/* Pre-conditions */
-	assert(PyList_CheckExact(consts));
-	assert(codestr[0] == LOAD_CONST);
-	assert(codestr[3] == LOAD_CONST);
-
-	/* Create new constant */
-	v = PyList_GET_ITEM(consts, GETARG(codestr, 0));
-	w = PyList_GET_ITEM(consts, GETARG(codestr, 3));
-	opcode = codestr[6];
-	switch (opcode) {
-		case BINARY_POWER:
-			newconst = PyNumber_Power(v, w, Py_None);
-			break;
-		case BINARY_MULTIPLY:
-			newconst = PyNumber_Multiply(v, w);
-			break;
-		case BINARY_DIVIDE:
-			/* Cannot fold this operation statically since
-                           the result can depend on the run-time presence
-                           of the -Qnew flag */
-			return 0;
-		case BINARY_TRUE_DIVIDE:
-			newconst = PyNumber_TrueDivide(v, w);
-			break;
-		case BINARY_FLOOR_DIVIDE:
-			newconst = PyNumber_FloorDivide(v, w);
-			break;
-		case BINARY_MODULO:
-			newconst = PyNumber_Remainder(v, w);
-			break;
-		case BINARY_ADD:
-			newconst = PyNumber_Add(v, w);
-			break;
-		case BINARY_SUBTRACT:
-			newconst = PyNumber_Subtract(v, w);
-			break;
-		case BINARY_SUBSCR:
-			newconst = PyObject_GetItem(v, w);
-			break;
-		case BINARY_LSHIFT:
-			newconst = PyNumber_Lshift(v, w);
-			break;
-		case BINARY_RSHIFT:
-			newconst = PyNumber_Rshift(v, w);
-			break;
-		case BINARY_AND:
-			newconst = PyNumber_And(v, w);
-			break;
-		case BINARY_XOR:
-			newconst = PyNumber_Xor(v, w);
-			break;
-		case BINARY_OR:
-			newconst = PyNumber_Or(v, w);
-			break;
-		default:
-			/* Called with an unknown opcode */
-			PyErr_Format(PyExc_SystemError,
-			     "unexpected binary operation %d on a constant",
-				     opcode);
-			return 0;
-	}
-	if (newconst == NULL) {
-		PyErr_Clear();
-		return 0;
-	}
-	size = PyObject_Size(newconst);
-	if (size == -1)
-		PyErr_Clear();
-	else if (size > 20) {
-		Py_DECREF(newconst);
-		return 0;
-	}
-
-	/* Append folded constant into consts table */
-	len_consts = PyList_GET_SIZE(consts);
-	if (PyList_Append(consts, newconst)) {
-		Py_DECREF(newconst);
-		return 0;
-	}
-	Py_DECREF(newconst);
-
-	/* Write NOP NOP NOP NOP LOAD_CONST newconst */
-	memset(codestr, NOP, 4);
-	codestr[4] = LOAD_CONST;
-	SETARG(codestr, 4, len_consts);
-	return 1;
+    PyObject *newconst, *v, *w;
+    Py_ssize_t len_consts, size;
+    int opcode;
+
+    /* Pre-conditions */
+    assert(PyList_CheckExact(consts));
+    assert(codestr[0] == LOAD_CONST);
+    assert(codestr[3] == LOAD_CONST);
+
+    /* Create new constant */
+    v = PyList_GET_ITEM(consts, GETARG(codestr, 0));
+    w = PyList_GET_ITEM(consts, GETARG(codestr, 3));
+    opcode = codestr[6];
+    switch (opcode) {
+        case BINARY_POWER:
+            newconst = PyNumber_Power(v, w, Py_None);
+            break;
+        case BINARY_MULTIPLY:
+            newconst = PyNumber_Multiply(v, w);
+            break;
+        case BINARY_DIVIDE:
+            /* Cannot fold this operation statically since
+               the result can depend on the run-time presence
+               of the -Qnew flag */
+            return 0;
+        case BINARY_TRUE_DIVIDE:
+            newconst = PyNumber_TrueDivide(v, w);
+            break;
+        case BINARY_FLOOR_DIVIDE:
+            newconst = PyNumber_FloorDivide(v, w);
+            break;
+        case BINARY_MODULO:
+            newconst = PyNumber_Remainder(v, w);
+            break;
+        case BINARY_ADD:
+            newconst = PyNumber_Add(v, w);
+            break;
+        case BINARY_SUBTRACT:
+            newconst = PyNumber_Subtract(v, w);
+            break;
+        case BINARY_SUBSCR:
+            newconst = PyObject_GetItem(v, w);
+            break;
+        case BINARY_LSHIFT:
+            newconst = PyNumber_Lshift(v, w);
+            break;
+        case BINARY_RSHIFT:
+            newconst = PyNumber_Rshift(v, w);
+            break;
+        case BINARY_AND:
+            newconst = PyNumber_And(v, w);
+            break;
+        case BINARY_XOR:
+            newconst = PyNumber_Xor(v, w);
+            break;
+        case BINARY_OR:
+            newconst = PyNumber_Or(v, w);
+            break;
+        default:
+            /* Called with an unknown opcode */
+            PyErr_Format(PyExc_SystemError,
+                 "unexpected binary operation %d on a constant",
+                     opcode);
+            return 0;
+    }
+    if (newconst == NULL) {
+        PyErr_Clear();
+        return 0;
+    }
+    size = PyObject_Size(newconst);
+    if (size == -1)
+        PyErr_Clear();
+    else if (size > 20) {
+        Py_DECREF(newconst);
+        return 0;
+    }
+
+    /* Append folded constant into consts table */
+    len_consts = PyList_GET_SIZE(consts);
+    if (PyList_Append(consts, newconst)) {
+        Py_DECREF(newconst);
+        return 0;
+    }
+    Py_DECREF(newconst);
+
+    /* Write NOP NOP NOP NOP LOAD_CONST newconst */
+    memset(codestr, NOP, 4);
+    codestr[4] = LOAD_CONST;
+    SETARG(codestr, 4, len_consts);
+    return 1;
 }
 
 static int
 fold_unaryops_on_constants(unsigned char *codestr, PyObject *consts)
 {
-	PyObject *newconst=NULL, *v;
-	Py_ssize_t len_consts;
-	int opcode;
-
-	/* Pre-conditions */
-	assert(PyList_CheckExact(consts));
-	assert(codestr[0] == LOAD_CONST);
-
-	/* Create new constant */
-	v = PyList_GET_ITEM(consts, GETARG(codestr, 0));
-	opcode = codestr[3];
-	switch (opcode) {
-		case UNARY_NEGATIVE:
-			/* Preserve the sign of -0.0 */
-			if (PyObject_IsTrue(v) == 1)
-				newconst = PyNumber_Negative(v);
-			break;
-		case UNARY_CONVERT:
-			newconst = PyObject_Repr(v);
-			break;
-		case UNARY_INVERT:
-			newconst = PyNumber_Invert(v);
-			break;
-		default:
-			/* Called with an unknown opcode */
-			PyErr_Format(PyExc_SystemError,
-			     "unexpected unary operation %d on a constant",
-				     opcode);
-			return 0;
-	}
-	if (newconst == NULL) {
-		PyErr_Clear();
-		return 0;
-	}
-
-	/* Append folded constant into consts table */
-	len_consts = PyList_GET_SIZE(consts);
-	if (PyList_Append(consts, newconst)) {
-		Py_DECREF(newconst);
-		return 0;
-	}
-	Py_DECREF(newconst);
-
-	/* Write NOP LOAD_CONST newconst */
-	codestr[0] = NOP;
-	codestr[1] = LOAD_CONST;
-	SETARG(codestr, 1, len_consts);
-	return 1;
+    PyObject *newconst=NULL, *v;
+    Py_ssize_t len_consts;
+    int opcode;
+
+    /* Pre-conditions */
+    assert(PyList_CheckExact(consts));
+    assert(codestr[0] == LOAD_CONST);
+
+    /* Create new constant */
+    v = PyList_GET_ITEM(consts, GETARG(codestr, 0));
+    opcode = codestr[3];
+    switch (opcode) {
+        case UNARY_NEGATIVE:
+            /* Preserve the sign of -0.0 */
+            if (PyObject_IsTrue(v) == 1)
+                newconst = PyNumber_Negative(v);
+            break;
+        case UNARY_CONVERT:
+            newconst = PyObject_Repr(v);
+            break;
+        case UNARY_INVERT:
+            newconst = PyNumber_Invert(v);
+            break;
+        default:
+            /* Called with an unknown opcode */
+            PyErr_Format(PyExc_SystemError,
+                 "unexpected unary operation %d on a constant",
+                     opcode);
+            return 0;
+    }
+    if (newconst == NULL) {
+        PyErr_Clear();
+        return 0;
+    }
+
+    /* Append folded constant into consts table */
+    len_consts = PyList_GET_SIZE(consts);
+    if (PyList_Append(consts, newconst)) {
+        Py_DECREF(newconst);
+        return 0;
+    }
+    Py_DECREF(newconst);
+
+    /* Write NOP LOAD_CONST newconst */
+    codestr[0] = NOP;
+    codestr[1] = LOAD_CONST;
+    SETARG(codestr, 1, len_consts);
+    return 1;
 }
 
 static unsigned int *
 markblocks(unsigned char *code, Py_ssize_t len)
 {
-	unsigned int *blocks = (unsigned int *)PyMem_Malloc(len*sizeof(int));
-	int i,j, opcode, blockcnt = 0;
-
-	if (blocks == NULL) {
-		PyErr_NoMemory();
-		return NULL;
-	}
-	memset(blocks, 0, len*sizeof(int));
-
-	/* Mark labels in the first pass */
-	for (i=0 ; i<len ; i+=CODESIZE(opcode)) {
-		opcode = code[i];
-		switch (opcode) {
-			case FOR_ITER:
-			case JUMP_FORWARD:
-			case JUMP_IF_FALSE_OR_POP:
-			case JUMP_IF_TRUE_OR_POP:
-			case POP_JUMP_IF_FALSE:
-			case POP_JUMP_IF_TRUE:
-			case JUMP_ABSOLUTE:
-			case CONTINUE_LOOP:
-			case SETUP_LOOP:
-			case SETUP_EXCEPT:
-			case SETUP_FINALLY:
-			case SETUP_WITH:
-				j = GETJUMPTGT(code, i);
-				blocks[j] = 1;
-				break;
-		}
-	}
-	/* Build block numbers in the second pass */
-	for (i=0 ; i<len ; i++) {
-		blockcnt += blocks[i];	/* increment blockcnt over labels */
-		blocks[i] = blockcnt;
-	}
-	return blocks;
+    unsigned int *blocks = (unsigned int *)PyMem_Malloc(len*sizeof(int));
+    int i,j, opcode, blockcnt = 0;
+
+    if (blocks == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    memset(blocks, 0, len*sizeof(int));
+
+    /* Mark labels in the first pass */
+    for (i=0 ; i<len ; i+=CODESIZE(opcode)) {
+        opcode = code[i];
+        switch (opcode) {
+            case FOR_ITER:
+            case JUMP_FORWARD:
+            case JUMP_IF_FALSE_OR_POP:
+            case JUMP_IF_TRUE_OR_POP:
+            case POP_JUMP_IF_FALSE:
+            case POP_JUMP_IF_TRUE:
+            case JUMP_ABSOLUTE:
+            case CONTINUE_LOOP:
+            case SETUP_LOOP:
+            case SETUP_EXCEPT:
+            case SETUP_FINALLY:
+            case SETUP_WITH:
+                j = GETJUMPTGT(code, i);
+                blocks[j] = 1;
+                break;
+        }
+    }
+    /* Build block numbers in the second pass */
+    for (i=0 ; i<len ; i++) {
+        blockcnt += blocks[i];          /* increment blockcnt over labels */
+        blocks[i] = blockcnt;
+    }
+    return blocks;
 }
 
 /* Perform basic peephole optimizations to components of a code object.
-   The consts object should still be in list form to allow new constants 
+   The consts object should still be in list form to allow new constants
    to be appended.
 
    To keep the optimizer simple, it bails out (does nothing) for code
-   containing extended arguments or that has a length over 32,700.  That 
-   allows us to avoid overflow and sign issues.	 Likewise, it bails when
+   containing extended arguments or that has a length over 32,700.  That
+   allows us to avoid overflow and sign issues.  Likewise, it bails when
    the lineno table has complex encoding for gaps >= 255.
 
    Optimizations are restricted to simple transformations occuring within a
-   single basic block.	All transformations keep the code size the same or 
-   smaller.  For those that reduce size, the gaps are initially filled with 
-   NOPs.  Later those NOPs are removed and the jump addresses retargeted in 
+   single basic block.  All transformations keep the code size the same or
+   smaller.  For those that reduce size, the gaps are initially filled with
+   NOPs.  Later those NOPs are removed and the jump addresses retargeted in
    a single pass.  Line numbering is adjusted accordingly. */
 
 PyObject *
 PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names,
                 PyObject *lineno_obj)
 {
-	Py_ssize_t i, j, codelen;
-	int nops, h, adj;
-	int tgt, tgttgt, opcode;
-	unsigned char *codestr = NULL;
-	unsigned char *lineno;
-	int *addrmap = NULL;
-	int new_line, cum_orig_line, last_line, tabsiz;
-	int cumlc=0, lastlc=0;	/* Count runs of consecutive LOAD_CONSTs */
-	unsigned int *blocks = NULL;
-	char *name;
-
-	/* Bail out if an exception is set */
-	if (PyErr_Occurred())
-		goto exitError;
-
-	/* Bypass optimization when the lineno table is too complex */
-	assert(PyString_Check(lineno_obj));
-	lineno = (unsigned char*)PyString_AS_STRING(lineno_obj);
-	tabsiz = PyString_GET_SIZE(lineno_obj);
-	if (memchr(lineno, 255, tabsiz) != NULL)
-		goto exitUnchanged;
-
-	/* Avoid situations where jump retargeting could overflow */
-	assert(PyString_Check(code));
-	codelen = PyString_GET_SIZE(code);
-	if (codelen > 32700)
-		goto exitUnchanged;
-
-	/* Make a modifiable copy of the code string */
-	codestr = (unsigned char *)PyMem_Malloc(codelen);
-	if (codestr == NULL)
-		goto exitError;
-	codestr = (unsigned char *)memcpy(codestr, 
-					  PyString_AS_STRING(code), codelen);
-
-	/* Verify that RETURN_VALUE terminates the codestring.	This allows
-	   the various transformation patterns to look ahead several
-	   instructions without additional checks to make sure they are not
-	   looking beyond the end of the code string.
-	*/
-	if (codestr[codelen-1] != RETURN_VALUE)
-		goto exitUnchanged;
-
-	/* Mapping to new jump targets after NOPs are removed */
-	addrmap = (int *)PyMem_Malloc(codelen * sizeof(int));
-	if (addrmap == NULL)
-		goto exitError;
-
-	blocks = markblocks(codestr, codelen);
-	if (blocks == NULL)
-		goto exitError;
-	assert(PyList_Check(consts));
-
-	for (i=0 ; i<codelen ; i += CODESIZE(codestr[i])) {
-	  reoptimize_current:
-		opcode = codestr[i];
-
-		lastlc = cumlc;
-		cumlc = 0;
-
-		switch (opcode) {
-			/* Replace UNARY_NOT POP_JUMP_IF_FALSE 
-			   with    POP_JUMP_IF_TRUE */
-			case UNARY_NOT:
-				if (codestr[i+1] != POP_JUMP_IF_FALSE
-				    || !ISBASICBLOCK(blocks,i,4))
-					continue;
-				j = GETARG(codestr, i+1);
-				codestr[i] = POP_JUMP_IF_TRUE;
-				SETARG(codestr, i, j);
-				codestr[i+3] = NOP;
-				goto reoptimize_current;
-
-				/* not a is b -->  a is not b
-				   not a in b -->  a not in b
-				   not a is not b -->  a is b
-				   not a not in b -->  a in b
-				*/
-			case COMPARE_OP:
-				j = GETARG(codestr, i);
-				if (j < 6  ||  j > 9  ||
-				    codestr[i+3] != UNARY_NOT  || 
-				    !ISBASICBLOCK(blocks,i,4))
-					continue;
-				SETARG(codestr, i, (j^1));
-				codestr[i+3] = NOP;
-				break;
-
-				/* Replace LOAD_GLOBAL/LOAD_NAME None
-                                   with LOAD_CONST None */
-			case LOAD_NAME:
-			case LOAD_GLOBAL:
-				j = GETARG(codestr, i);
-				name = PyString_AsString(PyTuple_GET_ITEM(names, j));
-				if (name == NULL  ||  strcmp(name, "None") != 0)
-					continue;
-				for (j=0 ; j < PyList_GET_SIZE(consts) ; j++) {
-					if (PyList_GET_ITEM(consts, j) == Py_None)
-						break;
-				}
-				if (j == PyList_GET_SIZE(consts)) {
-					if (PyList_Append(consts, Py_None) == -1)
-					        goto exitError;
-				}
-				assert(PyList_GET_ITEM(consts, j) == Py_None);
-				codestr[i] = LOAD_CONST;
-				SETARG(codestr, i, j);
-				cumlc = lastlc + 1;
-				break;
-
-				/* Skip over LOAD_CONST trueconst
-				   POP_JUMP_IF_FALSE xx. This improves
-				   "while 1" performance. */
-			case LOAD_CONST:
-				cumlc = lastlc + 1;
-				j = GETARG(codestr, i);
-				if (codestr[i+3] != POP_JUMP_IF_FALSE  ||
-				    !ISBASICBLOCK(blocks,i,6)  ||
-				    !PyObject_IsTrue(PyList_GET_ITEM(consts, j)))
-					continue;
-				memset(codestr+i, NOP, 6);
-				cumlc = 0;
-				break;
-
-				/* Try to fold tuples of constants (includes a case for lists
-				   which are only used for "in" and "not in" tests).
-				   Skip over BUILD_SEQN 1 UNPACK_SEQN 1.
-				   Replace BUILD_SEQN 2 UNPACK_SEQN 2 with ROT2.
-				   Replace BUILD_SEQN 3 UNPACK_SEQN 3 with ROT3 ROT2. */
-			case BUILD_TUPLE:
-			case BUILD_LIST:
-				j = GETARG(codestr, i);
-				h = i - 3 * j;
-				if (h >= 0  &&
-				    j <= lastlc	 &&
-				    ((opcode == BUILD_TUPLE && 
-				      ISBASICBLOCK(blocks, h, 3*(j+1))) ||
-				     (opcode == BUILD_LIST && 
-				      codestr[i+3]==COMPARE_OP && 
-				      ISBASICBLOCK(blocks, h, 3*(j+2)) &&
-				      (GETARG(codestr,i+3)==6 ||
-				       GETARG(codestr,i+3)==7))) &&
-				    tuple_of_constants(&codestr[h], j, consts)) {
-					assert(codestr[i] == LOAD_CONST);
-					cumlc = 1;
-					break;
-				}
-				if (codestr[i+3] != UNPACK_SEQUENCE  ||
-				    !ISBASICBLOCK(blocks,i,6) ||
-				    j != GETARG(codestr, i+3))
-					continue;
-				if (j == 1) {
-					memset(codestr+i, NOP, 6);
-				} else if (j == 2) {
-					codestr[i] = ROT_TWO;
-					memset(codestr+i+1, NOP, 5);
-				} else if (j == 3) {
-					codestr[i] = ROT_THREE;
-					codestr[i+1] = ROT_TWO;
-					memset(codestr+i+2, NOP, 4);
-				}
-				break;
-
-				/* Fold binary ops on constants.
-				   LOAD_CONST c1 LOAD_CONST c2 BINOP -->  LOAD_CONST binop(c1,c2) */
-			case BINARY_POWER:
-			case BINARY_MULTIPLY:
-			case BINARY_TRUE_DIVIDE:
-			case BINARY_FLOOR_DIVIDE:
-			case BINARY_MODULO:
-			case BINARY_ADD:
-			case BINARY_SUBTRACT:
-			case BINARY_SUBSCR:
-			case BINARY_LSHIFT:
-			case BINARY_RSHIFT:
-			case BINARY_AND:
-			case BINARY_XOR:
-			case BINARY_OR:
-				if (lastlc >= 2	 &&
-				    ISBASICBLOCK(blocks, i-6, 7)  &&
-				    fold_binops_on_constants(&codestr[i-6], consts)) {
-					i -= 2;
-					assert(codestr[i] == LOAD_CONST);
-					cumlc = 1;
-				}
-				break;
-
-				/* Fold unary ops on constants.
-				   LOAD_CONST c1  UNARY_OP -->	LOAD_CONST unary_op(c) */
-			case UNARY_NEGATIVE:
-			case UNARY_CONVERT:
-			case UNARY_INVERT:
-				if (lastlc >= 1	 &&
-				    ISBASICBLOCK(blocks, i-3, 4)  &&
-				    fold_unaryops_on_constants(&codestr[i-3], consts))	{
-					i -= 2;
-					assert(codestr[i] == LOAD_CONST);
-					cumlc = 1;
-				}
-				break;
-
-				/* Simplify conditional jump to conditional jump where the
-				   result of the first test implies the success of a similar
-				   test or the failure of the opposite test.
-				   Arises in code like:
-				   "if a and b:"
-				   "if a or b:"
-				   "a and b or c"
-				   "(a and b) and c"
-				   x:JUMP_IF_FALSE_OR_POP y   y:JUMP_IF_FALSE_OR_POP z
-				      -->  x:JUMP_IF_FALSE_OR_POP z
-				   x:JUMP_IF_FALSE_OR_POP y   y:JUMP_IF_TRUE_OR_POP z
-				      -->  x:POP_JUMP_IF_FALSE y+3
-				   where y+3 is the instruction following the second test.
-				*/
-			case JUMP_IF_FALSE_OR_POP:
-			case JUMP_IF_TRUE_OR_POP:
-				tgt = GETJUMPTGT(codestr, i);
-				j = codestr[tgt];
-				if (CONDITIONAL_JUMP(j)) {
-					/* NOTE: all possible jumps here are
-					   absolute! */
-					if (JUMPS_ON_TRUE(j) == JUMPS_ON_TRUE(opcode)) {
-						/* The second jump will be
-						   taken iff the first is. */
-						tgttgt = GETJUMPTGT(codestr, tgt);
-						/* The current opcode inherits
-						   its target's stack behaviour */
-						codestr[i] = j;
-						SETARG(codestr, i, tgttgt);
-						goto reoptimize_current;
-					} else {
-						/* The second jump is not taken
-						   if the first is (so jump past
-						   it), and all conditional
-						   jumps pop their argument when
-						   they're not taken (so change
-						   the first jump to pop its
-						   argument when it's taken). */
-						if (JUMPS_ON_TRUE(opcode))
-							codestr[i] = POP_JUMP_IF_TRUE;
-						else
-							codestr[i] = POP_JUMP_IF_FALSE;
-						SETARG(codestr, i, (tgt + 3));
-						goto reoptimize_current;
-					}
-				}
-				/* Intentional fallthrough */
-
-				/* Replace jumps to unconditional jumps */
-			case POP_JUMP_IF_FALSE:
-			case POP_JUMP_IF_TRUE:
-			case FOR_ITER:
-			case JUMP_FORWARD:
-			case JUMP_ABSOLUTE:
-			case CONTINUE_LOOP:
-			case SETUP_LOOP:
-			case SETUP_EXCEPT:
-			case SETUP_FINALLY:
-			case SETUP_WITH:
-				tgt = GETJUMPTGT(codestr, i);
-				/* Replace JUMP_* to a RETURN into just a RETURN */
-				if (UNCONDITIONAL_JUMP(opcode) &&
-				    codestr[tgt] == RETURN_VALUE) {
-					codestr[i] = RETURN_VALUE;
-					memset(codestr+i+1, NOP, 2);
-					continue;
-				}
-				if (!UNCONDITIONAL_JUMP(codestr[tgt]))
-					continue;
-				tgttgt = GETJUMPTGT(codestr, tgt);
-				if (opcode == JUMP_FORWARD) /* JMP_ABS can go backwards */
-					opcode = JUMP_ABSOLUTE;
-				if (!ABSOLUTE_JUMP(opcode))
-					tgttgt -= i + 3;     /* Calc relative jump addr */
-				if (tgttgt < 0)		  /* No backward relative jumps */
-					continue;
-				codestr[i] = opcode;
-				SETARG(codestr, i, tgttgt);
-				break;
-
-			case EXTENDED_ARG:
-				goto exitUnchanged;
-
-				/* Replace RETURN LOAD_CONST None RETURN with just RETURN */
-				/* Remove unreachable JUMPs after RETURN */
-			case RETURN_VALUE:
-				if (i+4 >= codelen)
-					continue;
-				if (codestr[i+4] == RETURN_VALUE &&
-				    ISBASICBLOCK(blocks,i,5))
-					memset(codestr+i+1, NOP, 4);
-				else if (UNCONDITIONAL_JUMP(codestr[i+1]) &&
-				         ISBASICBLOCK(blocks,i,4))
-					memset(codestr+i+1, NOP, 3);
-				break;
-		}
-	}
-
-	/* Fixup linenotab */
-	for (i=0, nops=0 ; i<codelen ; i += CODESIZE(codestr[i])) {
-		addrmap[i] = i - nops;
-		if (codestr[i] == NOP)
-			nops++;
-	}
-	cum_orig_line = 0;
-	last_line = 0;
-	for (i=0 ; i < tabsiz ; i+=2) {
-		cum_orig_line += lineno[i];
-		new_line = addrmap[cum_orig_line];
-		assert (new_line - last_line < 255);
-		lineno[i] =((unsigned char)(new_line - last_line));
-		last_line = new_line;
-	}
-
-	/* Remove NOPs and fixup jump targets */
-	for (i=0, h=0 ; i<codelen ; ) {
-		opcode = codestr[i];
-		switch (opcode) {
-			case NOP:
-				i++;
-				continue;
-
-			case JUMP_ABSOLUTE:
-			case CONTINUE_LOOP:
-			case POP_JUMP_IF_FALSE:
-			case POP_JUMP_IF_TRUE:
-			case JUMP_IF_FALSE_OR_POP:
-			case JUMP_IF_TRUE_OR_POP:
-				j = addrmap[GETARG(codestr, i)];
-				SETARG(codestr, i, j);
-				break;
-
-			case FOR_ITER:
-			case JUMP_FORWARD:
-			case SETUP_LOOP:
-			case SETUP_EXCEPT:
-			case SETUP_FINALLY:
-			case SETUP_WITH:
-				j = addrmap[GETARG(codestr, i) + i + 3] - addrmap[i] - 3;
-				SETARG(codestr, i, j);
-				break;
-		}
-		adj = CODESIZE(opcode);
-		while (adj--)
-			codestr[h++] = codestr[i++];
-	}
-	assert(h + nops == codelen);
-
-	code = PyString_FromStringAndSize((char *)codestr, h);
-	PyMem_Free(addrmap);
-	PyMem_Free(codestr);
-	PyMem_Free(blocks);
-	return code;
+    Py_ssize_t i, j, codelen;
+    int nops, h, adj;
+    int tgt, tgttgt, opcode;
+    unsigned char *codestr = NULL;
+    unsigned char *lineno;
+    int *addrmap = NULL;
+    int new_line, cum_orig_line, last_line, tabsiz;
+    int cumlc=0, lastlc=0;      /* Count runs of consecutive LOAD_CONSTs */
+    unsigned int *blocks = NULL;
+    char *name;
+
+    /* Bail out if an exception is set */
+    if (PyErr_Occurred())
+        goto exitError;
+
+    /* Bypass optimization when the lineno table is too complex */
+    assert(PyString_Check(lineno_obj));
+    lineno = (unsigned char*)PyString_AS_STRING(lineno_obj);
+    tabsiz = PyString_GET_SIZE(lineno_obj);
+    if (memchr(lineno, 255, tabsiz) != NULL)
+        goto exitUnchanged;
+
+    /* Avoid situations where jump retargeting could overflow */
+    assert(PyString_Check(code));
+    codelen = PyString_GET_SIZE(code);
+    if (codelen > 32700)
+        goto exitUnchanged;
+
+    /* Make a modifiable copy of the code string */
+    codestr = (unsigned char *)PyMem_Malloc(codelen);
+    if (codestr == NULL)
+        goto exitError;
+    codestr = (unsigned char *)memcpy(codestr,
+                                      PyString_AS_STRING(code), codelen);
+
+    /* Verify that RETURN_VALUE terminates the codestring.      This allows
+       the various transformation patterns to look ahead several
+       instructions without additional checks to make sure they are not
+       looking beyond the end of the code string.
+    */
+    if (codestr[codelen-1] != RETURN_VALUE)
+        goto exitUnchanged;
+
+    /* Mapping to new jump targets after NOPs are removed */
+    addrmap = (int *)PyMem_Malloc(codelen * sizeof(int));
+    if (addrmap == NULL)
+        goto exitError;
+
+    blocks = markblocks(codestr, codelen);
+    if (blocks == NULL)
+        goto exitError;
+    assert(PyList_Check(consts));
+
+    for (i=0 ; i<codelen ; i += CODESIZE(codestr[i])) {
+      reoptimize_current:
+        opcode = codestr[i];
+
+        lastlc = cumlc;
+        cumlc = 0;
+
+        switch (opcode) {
+            /* Replace UNARY_NOT POP_JUMP_IF_FALSE
+               with    POP_JUMP_IF_TRUE */
+            case UNARY_NOT:
+                if (codestr[i+1] != POP_JUMP_IF_FALSE
+                    || !ISBASICBLOCK(blocks,i,4))
+                    continue;
+                j = GETARG(codestr, i+1);
+                codestr[i] = POP_JUMP_IF_TRUE;
+                SETARG(codestr, i, j);
+                codestr[i+3] = NOP;
+                goto reoptimize_current;
+
+                /* not a is b -->  a is not b
+                   not a in b -->  a not in b
+                   not a is not b -->  a is b
+                   not a not in b -->  a in b
+                */
+            case COMPARE_OP:
+                j = GETARG(codestr, i);
+                if (j < 6  ||  j > 9  ||
+                    codestr[i+3] != UNARY_NOT  ||
+                    !ISBASICBLOCK(blocks,i,4))
+                    continue;
+                SETARG(codestr, i, (j^1));
+                codestr[i+3] = NOP;
+                break;
+
+                /* Replace LOAD_GLOBAL/LOAD_NAME None
+                   with LOAD_CONST None */
+            case LOAD_NAME:
+            case LOAD_GLOBAL:
+                j = GETARG(codestr, i);
+                name = PyString_AsString(PyTuple_GET_ITEM(names, j));
+                if (name == NULL  ||  strcmp(name, "None") != 0)
+                    continue;
+                for (j=0 ; j < PyList_GET_SIZE(consts) ; j++) {
+                    if (PyList_GET_ITEM(consts, j) == Py_None)
+                        break;
+                }
+                if (j == PyList_GET_SIZE(consts)) {
+                    if (PyList_Append(consts, Py_None) == -1)
+                        goto exitError;
+                }
+                assert(PyList_GET_ITEM(consts, j) == Py_None);
+                codestr[i] = LOAD_CONST;
+                SETARG(codestr, i, j);
+                cumlc = lastlc + 1;
+                break;
+
+                /* Skip over LOAD_CONST trueconst
+                   POP_JUMP_IF_FALSE xx. This improves
+                   "while 1" performance. */
+            case LOAD_CONST:
+                cumlc = lastlc + 1;
+                j = GETARG(codestr, i);
+                if (codestr[i+3] != POP_JUMP_IF_FALSE  ||
+                    !ISBASICBLOCK(blocks,i,6)  ||
+                    !PyObject_IsTrue(PyList_GET_ITEM(consts, j)))
+                    continue;
+                memset(codestr+i, NOP, 6);
+                cumlc = 0;
+                break;
+
+                /* Try to fold tuples of constants (includes a case for lists
+                   which are only used for "in" and "not in" tests).
+                   Skip over BUILD_SEQN 1 UNPACK_SEQN 1.
+                   Replace BUILD_SEQN 2 UNPACK_SEQN 2 with ROT2.
+                   Replace BUILD_SEQN 3 UNPACK_SEQN 3 with ROT3 ROT2. */
+            case BUILD_TUPLE:
+            case BUILD_LIST:
+                j = GETARG(codestr, i);
+                h = i - 3 * j;
+                if (h >= 0  &&
+                    j <= lastlc                  &&
+                    ((opcode == BUILD_TUPLE &&
+                      ISBASICBLOCK(blocks, h, 3*(j+1))) ||
+                     (opcode == BUILD_LIST &&
+                      codestr[i+3]==COMPARE_OP &&
+                      ISBASICBLOCK(blocks, h, 3*(j+2)) &&
+                      (GETARG(codestr,i+3)==6 ||
+                       GETARG(codestr,i+3)==7))) &&
+                    tuple_of_constants(&codestr[h], j, consts)) {
+                    assert(codestr[i] == LOAD_CONST);
+                    cumlc = 1;
+                    break;
+                }
+                if (codestr[i+3] != UNPACK_SEQUENCE  ||
+                    !ISBASICBLOCK(blocks,i,6) ||
+                    j != GETARG(codestr, i+3))
+                    continue;
+                if (j == 1) {
+                    memset(codestr+i, NOP, 6);
+                } else if (j == 2) {
+                    codestr[i] = ROT_TWO;
+                    memset(codestr+i+1, NOP, 5);
+                } else if (j == 3) {
+                    codestr[i] = ROT_THREE;
+                    codestr[i+1] = ROT_TWO;
+                    memset(codestr+i+2, NOP, 4);
+                }
+                break;
+
+                /* Fold binary ops on constants.
+                   LOAD_CONST c1 LOAD_CONST c2 BINOP -->  LOAD_CONST binop(c1,c2) */
+            case BINARY_POWER:
+            case BINARY_MULTIPLY:
+            case BINARY_TRUE_DIVIDE:
+            case BINARY_FLOOR_DIVIDE:
+            case BINARY_MODULO:
+            case BINARY_ADD:
+            case BINARY_SUBTRACT:
+            case BINARY_SUBSCR:
+            case BINARY_LSHIFT:
+            case BINARY_RSHIFT:
+            case BINARY_AND:
+            case BINARY_XOR:
+            case BINARY_OR:
+                if (lastlc >= 2                  &&
+                    ISBASICBLOCK(blocks, i-6, 7)  &&
+                    fold_binops_on_constants(&codestr[i-6], consts)) {
+                    i -= 2;
+                    assert(codestr[i] == LOAD_CONST);
+                    cumlc = 1;
+                }
+                break;
+
+                /* Fold unary ops on constants.
+                   LOAD_CONST c1  UNARY_OP -->                  LOAD_CONST unary_op(c) */
+            case UNARY_NEGATIVE:
+            case UNARY_CONVERT:
+            case UNARY_INVERT:
+                if (lastlc >= 1                  &&
+                    ISBASICBLOCK(blocks, i-3, 4)  &&
+                    fold_unaryops_on_constants(&codestr[i-3], consts))                  {
+                    i -= 2;
+                    assert(codestr[i] == LOAD_CONST);
+                    cumlc = 1;
+                }
+                break;
+
+                /* Simplify conditional jump to conditional jump where the
+                   result of the first test implies the success of a similar
+                   test or the failure of the opposite test.
+                   Arises in code like:
+                   "if a and b:"
+                   "if a or b:"
+                   "a and b or c"
+                   "(a and b) and c"
+                   x:JUMP_IF_FALSE_OR_POP y   y:JUMP_IF_FALSE_OR_POP z
+                      -->  x:JUMP_IF_FALSE_OR_POP z
+                   x:JUMP_IF_FALSE_OR_POP y   y:JUMP_IF_TRUE_OR_POP z
+                      -->  x:POP_JUMP_IF_FALSE y+3
+                   where y+3 is the instruction following the second test.
+                */
+            case JUMP_IF_FALSE_OR_POP:
+            case JUMP_IF_TRUE_OR_POP:
+                tgt = GETJUMPTGT(codestr, i);
+                j = codestr[tgt];
+                if (CONDITIONAL_JUMP(j)) {
+                    /* NOTE: all possible jumps here are
+                       absolute! */
+                    if (JUMPS_ON_TRUE(j) == JUMPS_ON_TRUE(opcode)) {
+                        /* The second jump will be
+                           taken iff the first is. */
+                        tgttgt = GETJUMPTGT(codestr, tgt);
+                        /* The current opcode inherits
+                           its target's stack behaviour */
+                        codestr[i] = j;
+                        SETARG(codestr, i, tgttgt);
+                        goto reoptimize_current;
+                    } else {
+                        /* The second jump is not taken
+                           if the first is (so jump past
+                           it), and all conditional
+                           jumps pop their argument when
+                           they're not taken (so change
+                           the first jump to pop its
+                           argument when it's taken). */
+                        if (JUMPS_ON_TRUE(opcode))
+                            codestr[i] = POP_JUMP_IF_TRUE;
+                        else
+                            codestr[i] = POP_JUMP_IF_FALSE;
+                        SETARG(codestr, i, (tgt + 3));
+                        goto reoptimize_current;
+                    }
+                }
+                /* Intentional fallthrough */
+
+                /* Replace jumps to unconditional jumps */
+            case POP_JUMP_IF_FALSE:
+            case POP_JUMP_IF_TRUE:
+            case FOR_ITER:
+            case JUMP_FORWARD:
+            case JUMP_ABSOLUTE:
+            case CONTINUE_LOOP:
+            case SETUP_LOOP:
+            case SETUP_EXCEPT:
+            case SETUP_FINALLY:
+            case SETUP_WITH:
+                tgt = GETJUMPTGT(codestr, i);
+                /* Replace JUMP_* to a RETURN into just a RETURN */
+                if (UNCONDITIONAL_JUMP(opcode) &&
+                    codestr[tgt] == RETURN_VALUE) {
+                    codestr[i] = RETURN_VALUE;
+                    memset(codestr+i+1, NOP, 2);
+                    continue;
+                }
+                if (!UNCONDITIONAL_JUMP(codestr[tgt]))
+                    continue;
+                tgttgt = GETJUMPTGT(codestr, tgt);
+                if (opcode == JUMP_FORWARD) /* JMP_ABS can go backwards */
+                    opcode = JUMP_ABSOLUTE;
+                if (!ABSOLUTE_JUMP(opcode))
+                    tgttgt -= i + 3;     /* Calc relative jump addr */
+                if (tgttgt < 0)                           /* No backward relative jumps */
+                    continue;
+                codestr[i] = opcode;
+                SETARG(codestr, i, tgttgt);
+                break;
+
+            case EXTENDED_ARG:
+                goto exitUnchanged;
+
+                /* Replace RETURN LOAD_CONST None RETURN with just RETURN */
+                /* Remove unreachable JUMPs after RETURN */
+            case RETURN_VALUE:
+                if (i+4 >= codelen)
+                    continue;
+                if (codestr[i+4] == RETURN_VALUE &&
+                    ISBASICBLOCK(blocks,i,5))
+                    memset(codestr+i+1, NOP, 4);
+                else if (UNCONDITIONAL_JUMP(codestr[i+1]) &&
+                         ISBASICBLOCK(blocks,i,4))
+                    memset(codestr+i+1, NOP, 3);
+                break;
+        }
+    }
+
+    /* Fixup linenotab */
+    for (i=0, nops=0 ; i<codelen ; i += CODESIZE(codestr[i])) {
+        addrmap[i] = i - nops;
+        if (codestr[i] == NOP)
+            nops++;
+    }
+    cum_orig_line = 0;
+    last_line = 0;
+    for (i=0 ; i < tabsiz ; i+=2) {
+        cum_orig_line += lineno[i];
+        new_line = addrmap[cum_orig_line];
+        assert (new_line - last_line < 255);
+        lineno[i] =((unsigned char)(new_line - last_line));
+        last_line = new_line;
+    }
+
+    /* Remove NOPs and fixup jump targets */
+    for (i=0, h=0 ; i<codelen ; ) {
+        opcode = codestr[i];
+        switch (opcode) {
+            case NOP:
+                i++;
+                continue;
+
+            case JUMP_ABSOLUTE:
+            case CONTINUE_LOOP:
+            case POP_JUMP_IF_FALSE:
+            case POP_JUMP_IF_TRUE:
+            case JUMP_IF_FALSE_OR_POP:
+            case JUMP_IF_TRUE_OR_POP:
+                j = addrmap[GETARG(codestr, i)];
+                SETARG(codestr, i, j);
+                break;
+
+            case FOR_ITER:
+            case JUMP_FORWARD:
+            case SETUP_LOOP:
+            case SETUP_EXCEPT:
+            case SETUP_FINALLY:
+            case SETUP_WITH:
+                j = addrmap[GETARG(codestr, i) + i + 3] - addrmap[i] - 3;
+                SETARG(codestr, i, j);
+                break;
+        }
+        adj = CODESIZE(opcode);
+        while (adj--)
+            codestr[h++] = codestr[i++];
+    }
+    assert(h + nops == codelen);
+
+    code = PyString_FromStringAndSize((char *)codestr, h);
+    PyMem_Free(addrmap);
+    PyMem_Free(codestr);
+    PyMem_Free(blocks);
+    return code;
 
  exitError:
-	code = NULL;
+    code = NULL;
 
  exitUnchanged:
-	if (blocks != NULL)
-		PyMem_Free(blocks);
-	if (addrmap != NULL)
-		PyMem_Free(addrmap);
-	if (codestr != NULL)
-		PyMem_Free(codestr);
-	Py_XINCREF(code);
-	return code;
+    if (blocks != NULL)
+        PyMem_Free(blocks);
+    if (addrmap != NULL)
+        PyMem_Free(addrmap);
+    if (codestr != NULL)
+        PyMem_Free(codestr);
+    Py_XINCREF(code);
+    return code;
 }
diff --git a/Python/pyarena.c b/Python/pyarena.c
index f4cc474..2d63638 100644
--- a/Python/pyarena.c
+++ b/Python/pyarena.c
@@ -12,32 +12,32 @@
 */
 
 #define DEFAULT_BLOCK_SIZE 8192
-#define ALIGNMENT		8
-#define ALIGNMENT_MASK		(ALIGNMENT - 1)
-#define ROUNDUP(x)		(((x) + ALIGNMENT_MASK) & ~ALIGNMENT_MASK)
+#define ALIGNMENT               8
+#define ALIGNMENT_MASK          (ALIGNMENT - 1)
+#define ROUNDUP(x)              (((x) + ALIGNMENT_MASK) & ~ALIGNMENT_MASK)
 
 typedef struct _block {
-	/* Total number of bytes owned by this block available to pass out.
-	 * Read-only after initialization.  The first such byte starts at
-	 * ab_mem.
-	 */
-	size_t ab_size;
-
-	/* Total number of bytes already passed out.  The next byte available
-	 * to pass out starts at ab_mem + ab_offset.
-	 */
-	size_t ab_offset;
-
-	/* An arena maintains a singly-linked, NULL-terminated list of
-	 * all blocks owned by the arena.  These are linked via the
-	 * ab_next member.
-	 */
-	struct _block *ab_next;
-
-	/* Pointer to the first allocatable byte owned by this block.  Read-
-	 * only after initialization.
-	 */
-	void *ab_mem;
+    /* Total number of bytes owned by this block available to pass out.
+     * Read-only after initialization.  The first such byte starts at
+     * ab_mem.
+     */
+    size_t ab_size;
+
+    /* Total number of bytes already passed out.  The next byte available
+     * to pass out starts at ab_mem + ab_offset.
+     */
+    size_t ab_offset;
+
+    /* An arena maintains a singly-linked, NULL-terminated list of
+     * all blocks owned by the arena.  These are linked via the
+     * ab_next member.
+     */
+    struct _block *ab_next;
+
+    /* Pointer to the first allocatable byte owned by this block.  Read-
+     * only after initialization.
+     */
+    void *ab_mem;
 } block;
 
 /* The arena manages two kinds of memory, blocks of raw memory
@@ -46,175 +46,175 @@ typedef struct _block {
 */
 
 struct _arena {
-        /* Pointer to the first block allocated for the arena, never NULL.
-           It is used only to find the first block when the arena is
-           being freed.
-         */
-	block *a_head;
-
-        /* Pointer to the block currently used for allocation.  It's
-           ab_next field should be NULL.  If it is not-null after a
-           call to block_alloc(), it means a new block has been allocated
-           and a_cur should be reset to point it.
-         */
-	block *a_cur;
-
-        /* A Python list object containing references to all the PyObject
-           pointers associated with this area.  They will be DECREFed
-           when the arena is freed.
-        */
-        PyObject *a_objects;
+    /* Pointer to the first block allocated for the arena, never NULL.
+       It is used only to find the first block when the arena is
+       being freed.
+     */
+    block *a_head;
+
+    /* Pointer to the block currently used for allocation.  It's
+       ab_next field should be NULL.  If it is not-null after a
+       call to block_alloc(), it means a new block has been allocated
+       and a_cur should be reset to point it.
+     */
+    block *a_cur;
+
+    /* A Python list object containing references to all the PyObject
+       pointers associated with this area.  They will be DECREFed
+       when the arena is freed.
+    */
+    PyObject *a_objects;
 
 #if defined(Py_DEBUG)
-        /* Debug output */
-        size_t total_allocs;
-        size_t total_size;
-        size_t total_blocks;
-        size_t total_block_size;
-        size_t total_big_blocks;
+    /* Debug output */
+    size_t total_allocs;
+    size_t total_size;
+    size_t total_blocks;
+    size_t total_block_size;
+    size_t total_big_blocks;
 #endif
 };
 
 static block *
 block_new(size_t size)
 {
-	/* Allocate header and block as one unit.
-	   ab_mem points just past header. */
-	block *b = (block *)malloc(sizeof(block) + size);
-	if (!b)
-		return NULL;
-	b->ab_size = size;
-	b->ab_mem = (void *)(b + 1);
-	b->ab_next = NULL;
-	b->ab_offset = ROUNDUP((Py_uintptr_t)(b->ab_mem)) - 
-	  (Py_uintptr_t)(b->ab_mem);
-	return b;
+    /* Allocate header and block as one unit.
+       ab_mem points just past header. */
+    block *b = (block *)malloc(sizeof(block) + size);
+    if (!b)
+        return NULL;
+    b->ab_size = size;
+    b->ab_mem = (void *)(b + 1);
+    b->ab_next = NULL;
+    b->ab_offset = ROUNDUP((Py_uintptr_t)(b->ab_mem)) -
+      (Py_uintptr_t)(b->ab_mem);
+    return b;
 }
 
 static void
 block_free(block *b) {
-	while (b) {
-		block *next = b->ab_next;
-		free(b);
-		b = next;
-	}
+    while (b) {
+        block *next = b->ab_next;
+        free(b);
+        b = next;
+    }
 }
 
 static void *
 block_alloc(block *b, size_t size)
 {
-	void *p;
-	assert(b);
-	size = ROUNDUP(size);
-	if (b->ab_offset + size > b->ab_size) {
-		/* If we need to allocate more memory than will fit in
-		   the default block, allocate a one-off block that is
-		   exactly the right size. */
-		/* TODO(jhylton): Think about space waste at end of block */
-		block *newbl = block_new(
-				size < DEFAULT_BLOCK_SIZE ?
-				DEFAULT_BLOCK_SIZE : size);
-		if (!newbl)
-			return NULL;
-		assert(!b->ab_next);
-		b->ab_next = newbl;
-		b = newbl;
-	}
-
-	assert(b->ab_offset + size <= b->ab_size);
-	p = (void *)(((char *)b->ab_mem) + b->ab_offset);
-	b->ab_offset += size;
-	return p;
+    void *p;
+    assert(b);
+    size = ROUNDUP(size);
+    if (b->ab_offset + size > b->ab_size) {
+        /* If we need to allocate more memory than will fit in
+           the default block, allocate a one-off block that is
+           exactly the right size. */
+        /* TODO(jhylton): Think about space waste at end of block */
+        block *newbl = block_new(
+                        size < DEFAULT_BLOCK_SIZE ?
+                        DEFAULT_BLOCK_SIZE : size);
+        if (!newbl)
+            return NULL;
+        assert(!b->ab_next);
+        b->ab_next = newbl;
+        b = newbl;
+    }
+
+    assert(b->ab_offset + size <= b->ab_size);
+    p = (void *)(((char *)b->ab_mem) + b->ab_offset);
+    b->ab_offset += size;
+    return p;
 }
 
 PyArena *
 PyArena_New()
 {
-	PyArena* arena = (PyArena *)malloc(sizeof(PyArena));
-	if (!arena)
-		return (PyArena*)PyErr_NoMemory();
-
-	arena->a_head = block_new(DEFAULT_BLOCK_SIZE);
-	arena->a_cur = arena->a_head;
-        if (!arena->a_head) {
-                free((void *)arena);
-                return (PyArena*)PyErr_NoMemory();
-        }
-        arena->a_objects = PyList_New(0);
-        if (!arena->a_objects) {
-                block_free(arena->a_head);
-                free((void *)arena);
-                return (PyArena*)PyErr_NoMemory();
-        }
+    PyArena* arena = (PyArena *)malloc(sizeof(PyArena));
+    if (!arena)
+        return (PyArena*)PyErr_NoMemory();
+
+    arena->a_head = block_new(DEFAULT_BLOCK_SIZE);
+    arena->a_cur = arena->a_head;
+    if (!arena->a_head) {
+        free((void *)arena);
+        return (PyArena*)PyErr_NoMemory();
+    }
+    arena->a_objects = PyList_New(0);
+    if (!arena->a_objects) {
+        block_free(arena->a_head);
+        free((void *)arena);
+        return (PyArena*)PyErr_NoMemory();
+    }
 #if defined(Py_DEBUG)
-        arena->total_allocs = 0;
-        arena->total_size = 0;
-        arena->total_blocks = 1;
-        arena->total_block_size = DEFAULT_BLOCK_SIZE;
-        arena->total_big_blocks = 0;
+    arena->total_allocs = 0;
+    arena->total_size = 0;
+    arena->total_blocks = 1;
+    arena->total_block_size = DEFAULT_BLOCK_SIZE;
+    arena->total_big_blocks = 0;
 #endif
-	return arena;
+    return arena;
 }
 
 void
 PyArena_Free(PyArena *arena)
 {
-        int r;
-	assert(arena);
+    int r;
+    assert(arena);
 #if defined(Py_DEBUG)
-        /*
-        fprintf(stderr,
-                "alloc=%d size=%d blocks=%d block_size=%d big=%d objects=%d\n",
-                arena->total_allocs, arena->total_size, arena->total_blocks,
-                arena->total_block_size, arena->total_big_blocks,
-                PyList_Size(arena->a_objects));
-        */
+    /*
+    fprintf(stderr,
+        "alloc=%d size=%d blocks=%d block_size=%d big=%d objects=%d\n",
+        arena->total_allocs, arena->total_size, arena->total_blocks,
+        arena->total_block_size, arena->total_big_blocks,
+        PyList_Size(arena->a_objects));
+    */
 #endif
-	block_free(arena->a_head);
-	/* This property normally holds, except when the code being compiled
-	   is sys.getobjects(0), in which case there will be two references.
-        assert(arena->a_objects->ob_refcnt == 1);
-	*/
-
-        /* Clear all the elements from the list.  This is necessary
-           to guarantee that they will be DECREFed. */
-        r = PyList_SetSlice(arena->a_objects,
-                            0, PyList_GET_SIZE(arena->a_objects), NULL);
-        assert(r == 0);
-        assert(PyList_GET_SIZE(arena->a_objects) == 0);
-        Py_DECREF(arena->a_objects);
-	free(arena);
+    block_free(arena->a_head);
+    /* This property normally holds, except when the code being compiled
+       is sys.getobjects(0), in which case there will be two references.
+    assert(arena->a_objects->ob_refcnt == 1);
+    */
+
+    /* Clear all the elements from the list.  This is necessary
+       to guarantee that they will be DECREFed. */
+    r = PyList_SetSlice(arena->a_objects,
+                        0, PyList_GET_SIZE(arena->a_objects), NULL);
+    assert(r == 0);
+    assert(PyList_GET_SIZE(arena->a_objects) == 0);
+    Py_DECREF(arena->a_objects);
+    free(arena);
 }
 
 void *
 PyArena_Malloc(PyArena *arena, size_t size)
 {
-	void *p = block_alloc(arena->a_cur, size);
-	if (!p)
-		return PyErr_NoMemory();
+    void *p = block_alloc(arena->a_cur, size);
+    if (!p)
+        return PyErr_NoMemory();
 #if defined(Py_DEBUG)
-        arena->total_allocs++;
-        arena->total_size += size;
+    arena->total_allocs++;
+    arena->total_size += size;
 #endif
-	/* Reset cur if we allocated a new block. */
-	if (arena->a_cur->ab_next) {
-		arena->a_cur = arena->a_cur->ab_next;
+    /* Reset cur if we allocated a new block. */
+    if (arena->a_cur->ab_next) {
+        arena->a_cur = arena->a_cur->ab_next;
 #if defined(Py_DEBUG)
-                arena->total_blocks++;
-                arena->total_block_size += arena->a_cur->ab_size;
-                if (arena->a_cur->ab_size > DEFAULT_BLOCK_SIZE)
-                        ++arena->total_big_blocks;
+        arena->total_blocks++;
+        arena->total_block_size += arena->a_cur->ab_size;
+        if (arena->a_cur->ab_size > DEFAULT_BLOCK_SIZE)
+            ++arena->total_big_blocks;
 #endif
-	}
-	return p;
+    }
+    return p;
 }
 
 int
 PyArena_AddPyObject(PyArena *arena, PyObject *obj)
 {
-        int r = PyList_Append(arena->a_objects, obj);
-        if (r >= 0) {
-                Py_DECREF(obj);
-        }
-        return r;
+    int r = PyList_Append(arena->a_objects, obj);
+    if (r >= 0) {
+        Py_DECREF(obj);
+    }
+    return r;
 }
diff --git a/Python/pymath.c b/Python/pymath.c
index 83105f2..827a773 100644
--- a/Python/pymath.c
+++ b/Python/pymath.c
@@ -7,9 +7,9 @@
    thus rounding from extended precision to double precision. */
 double _Py_force_double(double x)
 {
-	volatile double y;
-	y = x;
-	return y;
+    volatile double y;
+    y = x;
+    return y;
 }
 #endif
 
@@ -34,21 +34,21 @@ void _Py_set_387controlword(unsigned short cw) {
 #ifndef HAVE_HYPOT
 double hypot(double x, double y)
 {
-	double yx;
+    double yx;
 
-	x = fabs(x);
-	y = fabs(y);
-	if (x < y) {
-		double temp = x;
-		x = y;
-		y = temp;
-	}
-	if (x == 0.)
-		return 0.;
-	else {
-		yx = y/x;
-		return x*sqrt(1.+yx*yx);
-	}
+    x = fabs(x);
+    y = fabs(y);
+    if (x < y) {
+        double temp = x;
+        x = y;
+        y = temp;
+    }
+    if (x == 0.)
+        return 0.;
+    else {
+        yx = y/x;
+        return x*sqrt(1.+yx*yx);
+    }
 }
 #endif /* HAVE_HYPOT */
 
@@ -56,12 +56,12 @@ double hypot(double x, double y)
 double
 copysign(double x, double y)
 {
-	/* use atan2 to distinguish -0. from 0. */
-	if (y > 0. || (y == 0. && atan2(y, -1.) > 0.)) {
-		return fabs(x);
-	} else {
-		return -fabs(x);
-	}
+    /* use atan2 to distinguish -0. from 0. */
+    if (y > 0. || (y == 0. && atan2(y, -1.) > 0.)) {
+        return fabs(x);
+    } else {
+        return -fabs(x);
+    }
 }
 #endif /* HAVE_COPYSIGN */
 
@@ -73,7 +73,7 @@ round(double x)
     absx = fabs(x);
     y = floor(absx);
     if (absx - y >= 0.5)
-        y += 1.0;
+    y += 1.0;
     return copysign(y, x);
 }
 #endif /* HAVE_ROUND */
diff --git a/Python/pystate.c b/Python/pystate.c
index 343a97b..5afc01a 100644
--- a/Python/pystate.c
+++ b/Python/pystate.c
@@ -58,92 +58,92 @@ static void _PyGILState_NoteThreadState(PyThreadState* tstate);
 PyInterpreterState *
 PyInterpreterState_New(void)
 {
-	PyInterpreterState *interp = (PyInterpreterState *)
-				     malloc(sizeof(PyInterpreterState));
+    PyInterpreterState *interp = (PyInterpreterState *)
+                                 malloc(sizeof(PyInterpreterState));
 
-	if (interp != NULL) {
-		HEAD_INIT();
+    if (interp != NULL) {
+        HEAD_INIT();
 #ifdef WITH_THREAD
-		if (head_mutex == NULL)
-			Py_FatalError("Can't initialize threads for interpreter");
+        if (head_mutex == NULL)
+            Py_FatalError("Can't initialize threads for interpreter");
 #endif
-		interp->modules = NULL;
-		interp->modules_reloading = NULL;
-		interp->sysdict = NULL;
-		interp->builtins = NULL;
-		interp->tstate_head = NULL;
-		interp->codec_search_path = NULL;
-		interp->codec_search_cache = NULL;
-		interp->codec_error_registry = NULL;
+        interp->modules = NULL;
+        interp->modules_reloading = NULL;
+        interp->sysdict = NULL;
+        interp->builtins = NULL;
+        interp->tstate_head = NULL;
+        interp->codec_search_path = NULL;
+        interp->codec_search_cache = NULL;
+        interp->codec_error_registry = NULL;
 #ifdef HAVE_DLOPEN
 #ifdef RTLD_NOW
-                interp->dlopenflags = RTLD_NOW;
+        interp->dlopenflags = RTLD_NOW;
 #else
-		interp->dlopenflags = RTLD_LAZY;
+        interp->dlopenflags = RTLD_LAZY;
 #endif
 #endif
 #ifdef WITH_TSC
-		interp->tscdump = 0;
+        interp->tscdump = 0;
 #endif
 
-		HEAD_LOCK();
-		interp->next = interp_head;
-		interp_head = interp;
-		HEAD_UNLOCK();
-	}
+        HEAD_LOCK();
+        interp->next = interp_head;
+        interp_head = interp;
+        HEAD_UNLOCK();
+    }
 
-	return interp;
+    return interp;
 }
 
 
 void
 PyInterpreterState_Clear(PyInterpreterState *interp)
 {
-	PyThreadState *p;
-	HEAD_LOCK();
-	for (p = interp->tstate_head; p != NULL; p = p->next)
-		PyThreadState_Clear(p);
-	HEAD_UNLOCK();
-	Py_CLEAR(interp->codec_search_path);
-	Py_CLEAR(interp->codec_search_cache);
-	Py_CLEAR(interp->codec_error_registry);
-	Py_CLEAR(interp->modules);
-	Py_CLEAR(interp->modules_reloading);
-	Py_CLEAR(interp->sysdict);
-	Py_CLEAR(interp->builtins);
+    PyThreadState *p;
+    HEAD_LOCK();
+    for (p = interp->tstate_head; p != NULL; p = p->next)
+        PyThreadState_Clear(p);
+    HEAD_UNLOCK();
+    Py_CLEAR(interp->codec_search_path);
+    Py_CLEAR(interp->codec_search_cache);
+    Py_CLEAR(interp->codec_error_registry);
+    Py_CLEAR(interp->modules);
+    Py_CLEAR(interp->modules_reloading);
+    Py_CLEAR(interp->sysdict);
+    Py_CLEAR(interp->builtins);
 }
 
 
 static void
 zapthreads(PyInterpreterState *interp)
 {
-	PyThreadState *p;
-	/* No need to lock the mutex here because this should only happen
-	   when the threads are all really dead (XXX famous last words). */
-	while ((p = interp->tstate_head) != NULL) {
-		PyThreadState_Delete(p);
-	}
+    PyThreadState *p;
+    /* No need to lock the mutex here because this should only happen
+       when the threads are all really dead (XXX famous last words). */
+    while ((p = interp->tstate_head) != NULL) {
+        PyThreadState_Delete(p);
+    }
 }
 
 
 void
 PyInterpreterState_Delete(PyInterpreterState *interp)
 {
-	PyInterpreterState **p;
-	zapthreads(interp);
-	HEAD_LOCK();
-	for (p = &interp_head; ; p = &(*p)->next) {
-		if (*p == NULL)
-			Py_FatalError(
-				"PyInterpreterState_Delete: invalid interp");
-		if (*p == interp)
-			break;
-	}
-	if (interp->tstate_head != NULL)
-		Py_FatalError("PyInterpreterState_Delete: remaining threads");
-	*p = interp->next;
-	HEAD_UNLOCK();
-	free(interp);
+    PyInterpreterState **p;
+    zapthreads(interp);
+    HEAD_LOCK();
+    for (p = &interp_head; ; p = &(*p)->next) {
+        if (*p == NULL)
+            Py_FatalError(
+                "PyInterpreterState_Delete: invalid interp");
+        if (*p == interp)
+            break;
+    }
+    if (interp->tstate_head != NULL)
+        Py_FatalError("PyInterpreterState_Delete: remaining threads");
+    *p = interp->next;
+    HEAD_UNLOCK();
+    free(interp);
 }
 
 
@@ -151,104 +151,104 @@ PyInterpreterState_Delete(PyInterpreterState *interp)
 static struct _frame *
 threadstate_getframe(PyThreadState *self)
 {
-	return self->frame;
+    return self->frame;
 }
 
 static PyThreadState *
 new_threadstate(PyInterpreterState *interp, int init)
 {
-	PyThreadState *tstate = (PyThreadState *)malloc(sizeof(PyThreadState));
+    PyThreadState *tstate = (PyThreadState *)malloc(sizeof(PyThreadState));
 
-	if (_PyThreadState_GetFrame == NULL)
-		_PyThreadState_GetFrame = threadstate_getframe;
+    if (_PyThreadState_GetFrame == NULL)
+        _PyThreadState_GetFrame = threadstate_getframe;
 
-	if (tstate != NULL) {
-		tstate->interp = interp;
+    if (tstate != NULL) {
+        tstate->interp = interp;
 
-		tstate->frame = NULL;
-		tstate->recursion_depth = 0;
-		tstate->tracing = 0;
-		tstate->use_tracing = 0;
-		tstate->tick_counter = 0;
-		tstate->gilstate_counter = 0;
-		tstate->async_exc = NULL;
+        tstate->frame = NULL;
+        tstate->recursion_depth = 0;
+        tstate->tracing = 0;
+        tstate->use_tracing = 0;
+        tstate->tick_counter = 0;
+        tstate->gilstate_counter = 0;
+        tstate->async_exc = NULL;
 #ifdef WITH_THREAD
-		tstate->thread_id = PyThread_get_thread_ident();
+        tstate->thread_id = PyThread_get_thread_ident();
 #else
-		tstate->thread_id = 0;
+        tstate->thread_id = 0;
 #endif
 
-		tstate->dict = NULL;
+        tstate->dict = NULL;
 
-		tstate->curexc_type = NULL;
-		tstate->curexc_value = NULL;
-		tstate->curexc_traceback = NULL;
+        tstate->curexc_type = NULL;
+        tstate->curexc_value = NULL;
+        tstate->curexc_traceback = NULL;
 
-		tstate->exc_type = NULL;
-		tstate->exc_value = NULL;
-		tstate->exc_traceback = NULL;
+        tstate->exc_type = NULL;
+        tstate->exc_value = NULL;
+        tstate->exc_traceback = NULL;
 
-		tstate->c_profilefunc = NULL;
-		tstate->c_tracefunc = NULL;
-		tstate->c_profileobj = NULL;
-		tstate->c_traceobj = NULL;
+        tstate->c_profilefunc = NULL;
+        tstate->c_tracefunc = NULL;
+        tstate->c_profileobj = NULL;
+        tstate->c_traceobj = NULL;
 
-		if (init)
-			_PyThreadState_Init(tstate);
+        if (init)
+            _PyThreadState_Init(tstate);
 
-		HEAD_LOCK();
-		tstate->next = interp->tstate_head;
-		interp->tstate_head = tstate;
-		HEAD_UNLOCK();
-	}
+        HEAD_LOCK();
+        tstate->next = interp->tstate_head;
+        interp->tstate_head = tstate;
+        HEAD_UNLOCK();
+    }
 
-	return tstate;
+    return tstate;
 }
 
 PyThreadState *
 PyThreadState_New(PyInterpreterState *interp)
 {
-	return new_threadstate(interp, 1);
+    return new_threadstate(interp, 1);
 }
 
 PyThreadState *
 _PyThreadState_Prealloc(PyInterpreterState *interp)
 {
-	return new_threadstate(interp, 0);
+    return new_threadstate(interp, 0);
 }
 
 void
 _PyThreadState_Init(PyThreadState *tstate)
 {
 #ifdef WITH_THREAD
-	_PyGILState_NoteThreadState(tstate);
+    _PyGILState_NoteThreadState(tstate);
 #endif
 }
 
 void
 PyThreadState_Clear(PyThreadState *tstate)
 {
-	if (Py_VerboseFlag && tstate->frame != NULL)
-		fprintf(stderr,
-		  "PyThreadState_Clear: warning: thread still has a frame\n");
+    if (Py_VerboseFlag && tstate->frame != NULL)
+        fprintf(stderr,
+          "PyThreadState_Clear: warning: thread still has a frame\n");
 
-	Py_CLEAR(tstate->frame);
+    Py_CLEAR(tstate->frame);
 
-	Py_CLEAR(tstate->dict);
-	Py_CLEAR(tstate->async_exc);
+    Py_CLEAR(tstate->dict);
+    Py_CLEAR(tstate->async_exc);
 
-	Py_CLEAR(tstate->curexc_type);
-	Py_CLEAR(tstate->curexc_value);
-	Py_CLEAR(tstate->curexc_traceback);
+    Py_CLEAR(tstate->curexc_type);
+    Py_CLEAR(tstate->curexc_value);
+    Py_CLEAR(tstate->curexc_traceback);
 
-	Py_CLEAR(tstate->exc_type);
-	Py_CLEAR(tstate->exc_value);
-	Py_CLEAR(tstate->exc_traceback);
+    Py_CLEAR(tstate->exc_type);
+    Py_CLEAR(tstate->exc_value);
+    Py_CLEAR(tstate->exc_traceback);
 
-	tstate->c_profilefunc = NULL;
-	tstate->c_tracefunc = NULL;
-	Py_CLEAR(tstate->c_profileobj);
-	Py_CLEAR(tstate->c_traceobj);
+    tstate->c_profilefunc = NULL;
+    tstate->c_tracefunc = NULL;
+    Py_CLEAR(tstate->c_profileobj);
+    Py_CLEAR(tstate->c_traceobj);
 }
 
 
@@ -256,50 +256,50 @@ PyThreadState_Clear(PyThreadState *tstate)
 static void
 tstate_delete_common(PyThreadState *tstate)
 {
-	PyInterpreterState *interp;
-	PyThreadState **p;
-	PyThreadState *prev_p = NULL;
-	if (tstate == NULL)
-		Py_FatalError("PyThreadState_Delete: NULL tstate");
-	interp = tstate->interp;
-	if (interp == NULL)
-		Py_FatalError("PyThreadState_Delete: NULL interp");
-	HEAD_LOCK();
-	for (p = &interp->tstate_head; ; p = &(*p)->next) {
-		if (*p == NULL)
-			Py_FatalError(
-				"PyThreadState_Delete: invalid tstate");
-		if (*p == tstate)
-			break;
-		/* Sanity check.  These states should never happen but if
-		 * they do we must abort.  Otherwise we'll end up spinning in
-		 * in a tight loop with the lock held.  A similar check is done
-		 * in thread.c find_key().  */
-		if (*p == prev_p)
-			Py_FatalError(
-				"PyThreadState_Delete: small circular list(!)"
-                                " and tstate not found.");
-		prev_p = *p;
-		if ((*p)->next == interp->tstate_head)
-			Py_FatalError(
-				"PyThreadState_Delete: circular list(!) and"
-                                " tstate not found.");
-	}
-	*p = tstate->next;
-	HEAD_UNLOCK();
-	free(tstate);
+    PyInterpreterState *interp;
+    PyThreadState **p;
+    PyThreadState *prev_p = NULL;
+    if (tstate == NULL)
+        Py_FatalError("PyThreadState_Delete: NULL tstate");
+    interp = tstate->interp;
+    if (interp == NULL)
+        Py_FatalError("PyThreadState_Delete: NULL interp");
+    HEAD_LOCK();
+    for (p = &interp->tstate_head; ; p = &(*p)->next) {
+        if (*p == NULL)
+            Py_FatalError(
+                "PyThreadState_Delete: invalid tstate");
+        if (*p == tstate)
+            break;
+        /* Sanity check.  These states should never happen but if
+         * they do we must abort.  Otherwise we'll end up spinning in
+         * in a tight loop with the lock held.  A similar check is done
+         * in thread.c find_key().  */
+        if (*p == prev_p)
+            Py_FatalError(
+                "PyThreadState_Delete: small circular list(!)"
+                " and tstate not found.");
+        prev_p = *p;
+        if ((*p)->next == interp->tstate_head)
+            Py_FatalError(
+                "PyThreadState_Delete: circular list(!) and"
+                " tstate not found.");
+    }
+    *p = tstate->next;
+    HEAD_UNLOCK();
+    free(tstate);
 }
 
 
 void
 PyThreadState_Delete(PyThreadState *tstate)
 {
-	if (tstate == _PyThreadState_Current)
-		Py_FatalError("PyThreadState_Delete: tstate is still current");
-	tstate_delete_common(tstate);
+    if (tstate == _PyThreadState_Current)
+        Py_FatalError("PyThreadState_Delete: tstate is still current");
+    tstate_delete_common(tstate);
 #ifdef WITH_THREAD
-	if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate)
-		PyThread_delete_key_value(autoTLSkey);
+    if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate)
+        PyThread_delete_key_value(autoTLSkey);
 #endif /* WITH_THREAD */
 }
 
@@ -308,15 +308,15 @@ PyThreadState_Delete(PyThreadState *tstate)
 void
 PyThreadState_DeleteCurrent()
 {
-	PyThreadState *tstate = _PyThreadState_Current;
-	if (tstate == NULL)
-		Py_FatalError(
-			"PyThreadState_DeleteCurrent: no current tstate");
-	_PyThreadState_Current = NULL;
-	tstate_delete_common(tstate);
-	if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate)
-		PyThread_delete_key_value(autoTLSkey);
-	PyEval_ReleaseLock();
+    PyThreadState *tstate = _PyThreadState_Current;
+    if (tstate == NULL)
+        Py_FatalError(
+            "PyThreadState_DeleteCurrent: no current tstate");
+    _PyThreadState_Current = NULL;
+    tstate_delete_common(tstate);
+    if (autoTLSkey && PyThread_get_key_value(autoTLSkey) == tstate)
+        PyThread_delete_key_value(autoTLSkey);
+    PyEval_ReleaseLock();
 }
 #endif /* WITH_THREAD */
 
@@ -324,36 +324,36 @@ PyThreadState_DeleteCurrent()
 PyThreadState *
 PyThreadState_Get(void)
 {
-	if (_PyThreadState_Current == NULL)
-		Py_FatalError("PyThreadState_Get: no current thread");
+    if (_PyThreadState_Current == NULL)
+        Py_FatalError("PyThreadState_Get: no current thread");
 
-	return _PyThreadState_Current;
+    return _PyThreadState_Current;
 }
 
 
 PyThreadState *
 PyThreadState_Swap(PyThreadState *newts)
 {
-	PyThreadState *oldts = _PyThreadState_Current;
+    PyThreadState *oldts = _PyThreadState_Current;
 
-	_PyThreadState_Current = newts;
-	/* It should not be possible for more than one thread state
-	   to be used for a thread.  Check this the best we can in debug
-	   builds.
-	*/
+    _PyThreadState_Current = newts;
+    /* It should not be possible for more than one thread state
+       to be used for a thread.  Check this the best we can in debug
+       builds.
+    */
 #if defined(Py_DEBUG) && defined(WITH_THREAD)
-	if (newts) {
-		/* This can be called from PyEval_RestoreThread(). Similar
-		   to it, we need to ensure errno doesn't change.
-		*/
-		int err = errno;
-		PyThreadState *check = PyGILState_GetThisThreadState();
-		if (check && check->interp == newts->interp && check != newts)
-			Py_FatalError("Invalid thread state for this thread");
-		errno = err;
-	}
+    if (newts) {
+        /* This can be called from PyEval_RestoreThread(). Similar
+           to it, we need to ensure errno doesn't change.
+        */
+        int err = errno;
+        PyThreadState *check = PyGILState_GetThisThreadState();
+        if (check && check->interp == newts->interp && check != newts)
+            Py_FatalError("Invalid thread state for this thread");
+        errno = err;
+    }
 #endif
-	return oldts;
+    return oldts;
 }
 
 /* An extension mechanism to store arbitrary additional per-thread state.
@@ -365,16 +365,16 @@ PyThreadState_Swap(PyThreadState *newts)
 PyObject *
 PyThreadState_GetDict(void)
 {
-	if (_PyThreadState_Current == NULL)
-		return NULL;
-
-	if (_PyThreadState_Current->dict == NULL) {
-		PyObject *d;
-		_PyThreadState_Current->dict = d = PyDict_New();
-		if (d == NULL)
-			PyErr_Clear();
-	}
-	return _PyThreadState_Current->dict;
+    if (_PyThreadState_Current == NULL)
+        return NULL;
+
+    if (_PyThreadState_Current->dict == NULL) {
+        PyObject *d;
+        _PyThreadState_Current->dict = d = PyDict_New();
+        if (d == NULL)
+            PyErr_Clear();
+    }
+    return _PyThreadState_Current->dict;
 }
 
 
@@ -388,36 +388,36 @@ PyThreadState_GetDict(void)
 
 int
 PyThreadState_SetAsyncExc(long id, PyObject *exc) {
-	PyThreadState *tstate = PyThreadState_GET();
-	PyInterpreterState *interp = tstate->interp;
-	PyThreadState *p;
-
-	/* Although the GIL is held, a few C API functions can be called
-	 * without the GIL held, and in particular some that create and
-	 * destroy thread and interpreter states.  Those can mutate the
-	 * list of thread states we're traversing, so to prevent that we lock
-	 * head_mutex for the duration.
-	 */
-	HEAD_LOCK();
-	for (p = interp->tstate_head; p != NULL; p = p->next) {
-		if (p->thread_id == id) {
-			/* Tricky:  we need to decref the current value
-			 * (if any) in p->async_exc, but that can in turn
-			 * allow arbitrary Python code to run, including
-			 * perhaps calls to this function.  To prevent
-			 * deadlock, we need to release head_mutex before
-			 * the decref.
-			 */
-			PyObject *old_exc = p->async_exc;
-			Py_XINCREF(exc);
-			p->async_exc = exc;
-			HEAD_UNLOCK();
-			Py_XDECREF(old_exc);
-			return 1;
-		}
-	}
-	HEAD_UNLOCK();
-	return 0;
+    PyThreadState *tstate = PyThreadState_GET();
+    PyInterpreterState *interp = tstate->interp;
+    PyThreadState *p;
+
+    /* Although the GIL is held, a few C API functions can be called
+     * without the GIL held, and in particular some that create and
+     * destroy thread and interpreter states.  Those can mutate the
+     * list of thread states we're traversing, so to prevent that we lock
+     * head_mutex for the duration.
+     */
+    HEAD_LOCK();
+    for (p = interp->tstate_head; p != NULL; p = p->next) {
+        if (p->thread_id == id) {
+            /* Tricky:  we need to decref the current value
+             * (if any) in p->async_exc, but that can in turn
+             * allow arbitrary Python code to run, including
+             * perhaps calls to this function.  To prevent
+             * deadlock, we need to release head_mutex before
+             * the decref.
+             */
+            PyObject *old_exc = p->async_exc;
+            Py_XINCREF(exc);
+            p->async_exc = exc;
+            HEAD_UNLOCK();
+            Py_XDECREF(old_exc);
+            return 1;
+        }
+    }
+    HEAD_UNLOCK();
+    return 0;
 }
 
 
@@ -427,22 +427,22 @@ PyThreadState_SetAsyncExc(long id, PyObject *exc) {
 PyInterpreterState *
 PyInterpreterState_Head(void)
 {
-	return interp_head;
+    return interp_head;
 }
 
 PyInterpreterState *
 PyInterpreterState_Next(PyInterpreterState *interp) {
-	return interp->next;
+    return interp->next;
 }
 
 PyThreadState *
 PyInterpreterState_ThreadHead(PyInterpreterState *interp) {
-	return interp->tstate_head;
+    return interp->tstate_head;
 }
 
 PyThreadState *
 PyThreadState_Next(PyThreadState *tstate) {
-	return tstate->next;
+    return tstate->next;
 }
 
 /* The implementation of sys._current_frames().  This is intended to be
@@ -453,44 +453,44 @@ PyThreadState_Next(PyThreadState *tstate) {
 PyObject *
 _PyThread_CurrentFrames(void)
 {
-	PyObject *result;
-	PyInterpreterState *i;
-
-	result = PyDict_New();
-	if (result == NULL)
-		return NULL;
-
-	/* for i in all interpreters:
-	 *     for t in all of i's thread states:
-	 *          if t's frame isn't NULL, map t's id to its frame
-	 * Because these lists can mutute even when the GIL is held, we
-	 * need to grab head_mutex for the duration.
-	 */
-	HEAD_LOCK();
-	for (i = interp_head; i != NULL; i = i->next) {
-		PyThreadState *t;
-		for (t = i->tstate_head; t != NULL; t = t->next) {
-			PyObject *id;
-			int stat;
-			struct _frame *frame = t->frame;
-			if (frame == NULL)
-				continue;
-			id = PyInt_FromLong(t->thread_id);
-			if (id == NULL)
-				goto Fail;
-			stat = PyDict_SetItem(result, id, (PyObject *)frame);
-			Py_DECREF(id);
-			if (stat < 0)
-				goto Fail;
-		}
-	}
-	HEAD_UNLOCK();
-	return result;
+    PyObject *result;
+    PyInterpreterState *i;
+
+    result = PyDict_New();
+    if (result == NULL)
+        return NULL;
+
+    /* for i in all interpreters:
+     *     for t in all of i's thread states:
+     *          if t's frame isn't NULL, map t's id to its frame
+     * Because these lists can mutute even when the GIL is held, we
+     * need to grab head_mutex for the duration.
+     */
+    HEAD_LOCK();
+    for (i = interp_head; i != NULL; i = i->next) {
+        PyThreadState *t;
+        for (t = i->tstate_head; t != NULL; t = t->next) {
+            PyObject *id;
+            int stat;
+            struct _frame *frame = t->frame;
+            if (frame == NULL)
+                continue;
+            id = PyInt_FromLong(t->thread_id);
+            if (id == NULL)
+                goto Fail;
+            stat = PyDict_SetItem(result, id, (PyObject *)frame);
+            Py_DECREF(id);
+            if (stat < 0)
+                goto Fail;
+        }
+    }
+    HEAD_UNLOCK();
+    return result;
 
  Fail:
- 	HEAD_UNLOCK();
- 	Py_DECREF(result);
- 	return NULL;
+    HEAD_UNLOCK();
+    Py_DECREF(result);
+    return NULL;
 }
 
 /* Python "auto thread state" API. */
@@ -507,12 +507,12 @@ _PyThread_CurrentFrames(void)
 static int
 PyThreadState_IsCurrent(PyThreadState *tstate)
 {
-	/* Must be the tstate for this thread */
-	assert(PyGILState_GetThisThreadState()==tstate);
-	/* On Windows at least, simple reads and writes to 32 bit values
-	   are atomic.
-	*/
-	return tstate == _PyThreadState_Current;
+    /* Must be the tstate for this thread */
+    assert(PyGILState_GetThisThreadState()==tstate);
+    /* On Windows at least, simple reads and writes to 32 bit values
+       are atomic.
+    */
+    return tstate == _PyThreadState_Current;
 }
 
 /* Internal initialization/finalization functions called by
@@ -521,21 +521,21 @@ PyThreadState_IsCurrent(PyThreadState *tstate)
 void
 _PyGILState_Init(PyInterpreterState *i, PyThreadState *t)
 {
-	assert(i && t); /* must init with valid states */
-	autoTLSkey = PyThread_create_key();
-	autoInterpreterState = i;
-	assert(PyThread_get_key_value(autoTLSkey) == NULL);
-	assert(t->gilstate_counter == 0);
+    assert(i && t); /* must init with valid states */
+    autoTLSkey = PyThread_create_key();
+    autoInterpreterState = i;
+    assert(PyThread_get_key_value(autoTLSkey) == NULL);
+    assert(t->gilstate_counter == 0);
 
-	_PyGILState_NoteThreadState(t);
+    _PyGILState_NoteThreadState(t);
 }
 
 void
 _PyGILState_Fini(void)
 {
-	PyThread_delete_key(autoTLSkey);
-	autoTLSkey = 0;
-	autoInterpreterState = NULL;
+    PyThread_delete_key(autoTLSkey);
+    autoTLSkey = 0;
+    autoInterpreterState = NULL;
 }
 
 /* When a thread state is created for a thread by some mechanism other than
@@ -546,113 +546,113 @@ _PyGILState_Fini(void)
 static void
 _PyGILState_NoteThreadState(PyThreadState* tstate)
 {
-	/* If autoTLSkey is 0, this must be the very first threadstate created
-	   in Py_Initialize().  Don't do anything for now (we'll be back here
-	   when _PyGILState_Init is called). */
-	if (!autoTLSkey)
-		return;
-
-	/* Stick the thread state for this thread in thread local storage.
-
-	   The only situation where you can legitimately have more than one
-	   thread state for an OS level thread is when there are multiple
-	   interpreters, when:
-
-	       a) You shouldn't really be using the PyGILState_ APIs anyway,
-	          and:
-
-	       b) The slightly odd way PyThread_set_key_value works (see
-	          comments by its implementation) means that the first thread
-	          state created for that given OS level thread will "win",
-	          which seems reasonable behaviour.
-	*/
-	if (PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0)
-		Py_FatalError("Couldn't create autoTLSkey mapping");
-
-	/* PyGILState_Release must not try to delete this thread state. */
-	tstate->gilstate_counter = 1;
+    /* If autoTLSkey is 0, this must be the very first threadstate created
+       in Py_Initialize().  Don't do anything for now (we'll be back here
+       when _PyGILState_Init is called). */
+    if (!autoTLSkey)
+        return;
+
+    /* Stick the thread state for this thread in thread local storage.
+
+       The only situation where you can legitimately have more than one
+       thread state for an OS level thread is when there are multiple
+       interpreters, when:
+
+           a) You shouldn't really be using the PyGILState_ APIs anyway,
+          and:
+
+           b) The slightly odd way PyThread_set_key_value works (see
+          comments by its implementation) means that the first thread
+          state created for that given OS level thread will "win",
+          which seems reasonable behaviour.
+    */
+    if (PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0)
+        Py_FatalError("Couldn't create autoTLSkey mapping");
+
+    /* PyGILState_Release must not try to delete this thread state. */
+    tstate->gilstate_counter = 1;
 }
 
 /* The public functions */
 PyThreadState *
 PyGILState_GetThisThreadState(void)
 {
-	if (autoInterpreterState == NULL || autoTLSkey == 0)
-		return NULL;
-	return (PyThreadState *)PyThread_get_key_value(autoTLSkey);
+    if (autoInterpreterState == NULL || autoTLSkey == 0)
+        return NULL;
+    return (PyThreadState *)PyThread_get_key_value(autoTLSkey);
 }
 
 PyGILState_STATE
 PyGILState_Ensure(void)
 {
-	int current;
-	PyThreadState *tcur;
-	/* Note that we do not auto-init Python here - apart from
-	   potential races with 2 threads auto-initializing, pep-311
-	   spells out other issues.  Embedders are expected to have
-	   called Py_Initialize() and usually PyEval_InitThreads().
-	*/
-	assert(autoInterpreterState); /* Py_Initialize() hasn't been called! */
-	tcur = (PyThreadState *)PyThread_get_key_value(autoTLSkey);
-	if (tcur == NULL) {
-		/* Create a new thread state for this thread */
-		tcur = PyThreadState_New(autoInterpreterState);
-		if (tcur == NULL)
-			Py_FatalError("Couldn't create thread-state for new thread");
-		/* This is our thread state!  We'll need to delete it in the
-		   matching call to PyGILState_Release(). */
-		tcur->gilstate_counter = 0;
-		current = 0; /* new thread state is never current */
-	}
-	else
-		current = PyThreadState_IsCurrent(tcur);
-	if (current == 0)
-		PyEval_RestoreThread(tcur);
-	/* Update our counter in the thread-state - no need for locks:
-	   - tcur will remain valid as we hold the GIL.
-	   - the counter is safe as we are the only thread "allowed"
-	     to modify this value
-	*/
-	++tcur->gilstate_counter;
-	return current ? PyGILState_LOCKED : PyGILState_UNLOCKED;
+    int current;
+    PyThreadState *tcur;
+    /* Note that we do not auto-init Python here - apart from
+       potential races with 2 threads auto-initializing, pep-311
+       spells out other issues.  Embedders are expected to have
+       called Py_Initialize() and usually PyEval_InitThreads().
+    */
+    assert(autoInterpreterState); /* Py_Initialize() hasn't been called! */
+    tcur = (PyThreadState *)PyThread_get_key_value(autoTLSkey);
+    if (tcur == NULL) {
+        /* Create a new thread state for this thread */
+        tcur = PyThreadState_New(autoInterpreterState);
+        if (tcur == NULL)
+            Py_FatalError("Couldn't create thread-state for new thread");
+        /* This is our thread state!  We'll need to delete it in the
+           matching call to PyGILState_Release(). */
+        tcur->gilstate_counter = 0;
+        current = 0; /* new thread state is never current */
+    }
+    else
+        current = PyThreadState_IsCurrent(tcur);
+    if (current == 0)
+        PyEval_RestoreThread(tcur);
+    /* Update our counter in the thread-state - no need for locks:
+       - tcur will remain valid as we hold the GIL.
+       - the counter is safe as we are the only thread "allowed"
+         to modify this value
+    */
+    ++tcur->gilstate_counter;
+    return current ? PyGILState_LOCKED : PyGILState_UNLOCKED;
 }
 
 void
 PyGILState_Release(PyGILState_STATE oldstate)
 {
-	PyThreadState *tcur = (PyThreadState *)PyThread_get_key_value(
-                                                                autoTLSkey);
-	if (tcur == NULL)
-		Py_FatalError("auto-releasing thread-state, "
-		              "but no thread-state for this thread");
-	/* We must hold the GIL and have our thread state current */
-	/* XXX - remove the check - the assert should be fine,
-	   but while this is very new (April 2003), the extra check
-	   by release-only users can't hurt.
-	*/
-	if (! PyThreadState_IsCurrent(tcur))
-		Py_FatalError("This thread state must be current when releasing");
-	assert(PyThreadState_IsCurrent(tcur));
-	--tcur->gilstate_counter;
-	assert(tcur->gilstate_counter >= 0); /* illegal counter value */
-
-	/* If we're going to destroy this thread-state, we must
-	 * clear it while the GIL is held, as destructors may run.
-	 */
-	if (tcur->gilstate_counter == 0) {
-		/* can't have been locked when we created it */
-		assert(oldstate == PyGILState_UNLOCKED);
-		PyThreadState_Clear(tcur);
-		/* Delete the thread-state.  Note this releases the GIL too!
-		 * It's vital that the GIL be held here, to avoid shutdown
-		 * races; see bugs 225673 and 1061968 (that nasty bug has a
-		 * habit of coming back).
-		 */
-		PyThreadState_DeleteCurrent();
-	}
-	/* Release the lock if necessary */
-	else if (oldstate == PyGILState_UNLOCKED)
-		PyEval_SaveThread();
+    PyThreadState *tcur = (PyThreadState *)PyThread_get_key_value(
+                                                            autoTLSkey);
+    if (tcur == NULL)
+        Py_FatalError("auto-releasing thread-state, "
+                      "but no thread-state for this thread");
+    /* We must hold the GIL and have our thread state current */
+    /* XXX - remove the check - the assert should be fine,
+       but while this is very new (April 2003), the extra check
+       by release-only users can't hurt.
+    */
+    if (! PyThreadState_IsCurrent(tcur))
+        Py_FatalError("This thread state must be current when releasing");
+    assert(PyThreadState_IsCurrent(tcur));
+    --tcur->gilstate_counter;
+    assert(tcur->gilstate_counter >= 0); /* illegal counter value */
+
+    /* If we're going to destroy this thread-state, we must
+     * clear it while the GIL is held, as destructors may run.
+     */
+    if (tcur->gilstate_counter == 0) {
+        /* can't have been locked when we created it */
+        assert(oldstate == PyGILState_UNLOCKED);
+        PyThreadState_Clear(tcur);
+        /* Delete the thread-state.  Note this releases the GIL too!
+         * It's vital that the GIL be held here, to avoid shutdown
+         * races; see bugs 225673 and 1061968 (that nasty bug has a
+         * habit of coming back).
+         */
+        PyThreadState_DeleteCurrent();
+    }
+    /* Release the lock if necessary */
+    else if (oldstate == PyGILState_UNLOCKED)
+        PyEval_SaveThread();
 }
 
 #ifdef __cplusplus
diff --git a/Python/pystrcmp.c b/Python/pystrcmp.c
index 84295e7..f9c2277 100644
--- a/Python/pystrcmp.c
+++ b/Python/pystrcmp.c
@@ -6,21 +6,21 @@
 int
 PyOS_mystrnicmp(const char *s1, const char *s2, Py_ssize_t size)
 {
-	if (size == 0)
-		return 0;
-	while ((--size > 0) &&
-	       (tolower((unsigned)*s1) == tolower((unsigned)*s2))) {
-		if (!*s1++ || !*s2++)
-			break;
-	}
-	return tolower((unsigned)*s1) - tolower((unsigned)*s2);
+    if (size == 0)
+        return 0;
+    while ((--size > 0) &&
+           (tolower((unsigned)*s1) == tolower((unsigned)*s2))) {
+        if (!*s1++ || !*s2++)
+            break;
+    }
+    return tolower((unsigned)*s1) - tolower((unsigned)*s2);
 }
 
 int
 PyOS_mystricmp(const char *s1, const char *s2)
 {
-	while (*s1 && (tolower((unsigned)*s1++) == tolower((unsigned)*s2++))) {
-		;
-	}
-	return (tolower((unsigned)*s1) - tolower((unsigned)*s2));
+    while (*s1 && (tolower((unsigned)*s1++) == tolower((unsigned)*s2++))) {
+        ;
+    }
+    return (tolower((unsigned)*s1) - tolower((unsigned)*s2));
 }
diff --git a/Python/pystrtod.c b/Python/pystrtod.c
index 909e021..859af43 100644
--- a/Python/pystrtod.c
+++ b/Python/pystrtod.c
@@ -9,11 +9,11 @@
 static int
 case_insensitive_match(const char *s, const char *t)
 {
-	while(*t && Py_TOLOWER(*s) == *t) {
-		s++;
-		t++;
-	}
-	return *t ? 0 : 1;
+    while(*t && Py_TOLOWER(*s) == *t) {
+        s++;
+        t++;
+    }
+    return *t ? 0 : 1;
 }
 
 /* _Py_parse_inf_or_nan: Attempt to parse a string of the form "nan", "inf" or
@@ -25,36 +25,36 @@ case_insensitive_match(const char *s, const char *t)
 double
 _Py_parse_inf_or_nan(const char *p, char **endptr)
 {
-	double retval;
-	const char *s;
-	int negate = 0;
-
-	s = p;
-	if (*s == '-') {
-		negate = 1;
-		s++;
-	}
-	else if (*s == '+') {
-		s++;
-	}
-	if (case_insensitive_match(s, "inf")) {
-		s += 3;
-		if (case_insensitive_match(s, "inity"))
-			s += 5;
-		retval = negate ? -Py_HUGE_VAL : Py_HUGE_VAL;
-	}
+    double retval;
+    const char *s;
+    int negate = 0;
+
+    s = p;
+    if (*s == '-') {
+        negate = 1;
+        s++;
+    }
+    else if (*s == '+') {
+        s++;
+    }
+    if (case_insensitive_match(s, "inf")) {
+        s += 3;
+        if (case_insensitive_match(s, "inity"))
+            s += 5;
+        retval = negate ? -Py_HUGE_VAL : Py_HUGE_VAL;
+    }
 #ifdef Py_NAN
-	else if (case_insensitive_match(s, "nan")) {
-		s += 3;
-		retval = negate ? -Py_NAN : Py_NAN;
-	}
+    else if (case_insensitive_match(s, "nan")) {
+        s += 3;
+        retval = negate ? -Py_NAN : Py_NAN;
+    }
 #endif
-	else {
-		s = p;
-		retval = -1.0;
-	}
-	*endptr = (char *)s;
-	return retval;
+    else {
+        s = p;
+        retval = -1.0;
+    }
+    *endptr = (char *)s;
+    return retval;
 }
 
 /**
@@ -62,7 +62,7 @@ _Py_parse_inf_or_nan(const char *p, char **endptr)
  * @nptr:    the string to convert to a numeric value.
  * @endptr:  if non-%NULL, it returns the character after
  *           the last character used in the conversion.
- * 
+ *
  * Converts a string to a #gdouble value.
  * This function behaves like the standard strtod() function
  * does in the C locale. It does this without actually
@@ -79,7 +79,7 @@ _Py_parse_inf_or_nan(const char *p, char **endptr)
  * stored in %errno. If the correct value would cause underflow,
  * zero is returned and %ERANGE is stored in %errno.
  * If memory allocation fails, %ENOMEM is stored in %errno.
- * 
+ *
  * This function resets %errno before calling strtod() so that
  * you can reliably detect overflow and underflow.
  *
@@ -91,23 +91,23 @@ _Py_parse_inf_or_nan(const char *p, char **endptr)
 double
 _PyOS_ascii_strtod(const char *nptr, char **endptr)
 {
-	double result;
-	_Py_SET_53BIT_PRECISION_HEADER;
+    double result;
+    _Py_SET_53BIT_PRECISION_HEADER;
 
-	assert(nptr != NULL);
-	/* Set errno to zero, so that we can distinguish zero results
-	   and underflows */
-	errno = 0;
+    assert(nptr != NULL);
+    /* Set errno to zero, so that we can distinguish zero results
+       and underflows */
+    errno = 0;
 
-	_Py_SET_53BIT_PRECISION_START;
-	result = _Py_dg_strtod(nptr, endptr);
-	_Py_SET_53BIT_PRECISION_END;
+    _Py_SET_53BIT_PRECISION_START;
+    result = _Py_dg_strtod(nptr, endptr);
+    _Py_SET_53BIT_PRECISION_END;
 
-	if (*endptr == nptr)
-		/* string might represent an inf or nan */
-		result = _Py_parse_inf_or_nan(nptr, endptr);
+    if (*endptr == nptr)
+        /* string might represent an inf or nan */
+        result = _Py_parse_inf_or_nan(nptr, endptr);
 
-	return result;
+    return result;
 
 }
 
@@ -124,148 +124,148 @@ _PyOS_ascii_strtod(const char *nptr, char **endptr)
 double
 _PyOS_ascii_strtod(const char *nptr, char **endptr)
 {
-	char *fail_pos;
-	double val = -1.0;
-	struct lconv *locale_data;
-	const char *decimal_point;
-	size_t decimal_point_len;
-	const char *p, *decimal_point_pos;
-	const char *end = NULL; /* Silence gcc */
-	const char *digits_pos = NULL;
-	int negate = 0;
-
-	assert(nptr != NULL);
-
-	fail_pos = NULL;
-
-	locale_data = localeconv();
-	decimal_point = locale_data->decimal_point;
-	decimal_point_len = strlen(decimal_point);
-
-	assert(decimal_point_len != 0);
-
-	decimal_point_pos = NULL;
-
-	/* Parse infinities and nans */
-	val = _Py_parse_inf_or_nan(nptr, endptr);
-	if (*endptr != nptr)
-		return val;
-
-	/* Set errno to zero, so that we can distinguish zero results
-	   and underflows */
-	errno = 0;
-
-	/* We process the optional sign manually, then pass the remainder to
-	   the system strtod.  This ensures that the result of an underflow
-	   has the correct sign. (bug #1725)  */
-	p = nptr;
-	/* Process leading sign, if present */
-	if (*p == '-') {
-		negate = 1;
-		p++;
-	}
-	else if (*p == '+') {
-		p++;
-	}
-
-	/* Some platform strtods accept hex floats; Python shouldn't (at the
-	   moment), so we check explicitly for strings starting with '0x'. */
-	if (*p == '0' && (*(p+1) == 'x' || *(p+1) == 'X'))
-		goto invalid_string;
-
-	/* Check that what's left begins with a digit or decimal point */
-	if (!Py_ISDIGIT(*p) && *p != '.')
-		goto invalid_string;
-
-	digits_pos = p;
-	if (decimal_point[0] != '.' ||
-	    decimal_point[1] != 0)
-	{
-		/* Look for a '.' in the input; if present, it'll need to be
-		   swapped for the current locale's decimal point before we
-		   call strtod.  On the other hand, if we find the current
-		   locale's decimal point then the input is invalid. */
-		while (Py_ISDIGIT(*p))
-			p++;
-
-		if (*p == '.')
-		{
-			decimal_point_pos = p++;
-
-			/* locate end of number */
-			while (Py_ISDIGIT(*p))
-				p++;
-
-			if (*p == 'e' || *p == 'E')
-				p++;
-			if (*p == '+' || *p == '-')
-				p++;
-			while (Py_ISDIGIT(*p))
-				p++;
-			end = p;
-		}
-		else if (strncmp(p, decimal_point, decimal_point_len) == 0)
-			/* Python bug #1417699 */
-			goto invalid_string;
-		/* For the other cases, we need not convert the decimal
-		   point */
-	}
-
-	if (decimal_point_pos) {
-		char *copy, *c;
-		/* Create a copy of the input, with the '.' converted to the
-		   locale-specific decimal point */
-		copy = (char *)PyMem_MALLOC(end - digits_pos +
-					    1 + decimal_point_len);
-		if (copy == NULL) {
-			*endptr = (char *)nptr;
-			errno = ENOMEM;
-			return val;
-		}
-
-		c = copy;
-		memcpy(c, digits_pos, decimal_point_pos - digits_pos);
-		c += decimal_point_pos - digits_pos;
-		memcpy(c, decimal_point, decimal_point_len);
-		c += decimal_point_len;
-		memcpy(c, decimal_point_pos + 1,
-		       end - (decimal_point_pos + 1));
-		c += end - (decimal_point_pos + 1);
-		*c = 0;
-
-		val = strtod(copy, &fail_pos);
-
-		if (fail_pos)
-		{
-			if (fail_pos > decimal_point_pos)
-				fail_pos = (char *)digits_pos +
-					(fail_pos - copy) -
-					(decimal_point_len - 1);
-			else
-				fail_pos = (char *)digits_pos +
-					(fail_pos - copy);
-		}
-
-		PyMem_FREE(copy);
-
-	}
-	else {
-		val = strtod(digits_pos, &fail_pos);
-	}
-
-	if (fail_pos == digits_pos)
-		goto invalid_string;
-
-	if (negate && fail_pos != nptr)
-		val = -val;
-	*endptr = fail_pos;
-
-	return val;
+    char *fail_pos;
+    double val = -1.0;
+    struct lconv *locale_data;
+    const char *decimal_point;
+    size_t decimal_point_len;
+    const char *p, *decimal_point_pos;
+    const char *end = NULL; /* Silence gcc */
+    const char *digits_pos = NULL;
+    int negate = 0;
+
+    assert(nptr != NULL);
+
+    fail_pos = NULL;
+
+    locale_data = localeconv();
+    decimal_point = locale_data->decimal_point;
+    decimal_point_len = strlen(decimal_point);
+
+    assert(decimal_point_len != 0);
+
+    decimal_point_pos = NULL;
+
+    /* Parse infinities and nans */
+    val = _Py_parse_inf_or_nan(nptr, endptr);
+    if (*endptr != nptr)
+        return val;
+
+    /* Set errno to zero, so that we can distinguish zero results
+       and underflows */
+    errno = 0;
+
+    /* We process the optional sign manually, then pass the remainder to
+       the system strtod.  This ensures that the result of an underflow
+       has the correct sign. (bug #1725)  */
+    p = nptr;
+    /* Process leading sign, if present */
+    if (*p == '-') {
+        negate = 1;
+        p++;
+    }
+    else if (*p == '+') {
+        p++;
+    }
+
+    /* Some platform strtods accept hex floats; Python shouldn't (at the
+       moment), so we check explicitly for strings starting with '0x'. */
+    if (*p == '0' && (*(p+1) == 'x' || *(p+1) == 'X'))
+        goto invalid_string;
+
+    /* Check that what's left begins with a digit or decimal point */
+    if (!Py_ISDIGIT(*p) && *p != '.')
+        goto invalid_string;
+
+    digits_pos = p;
+    if (decimal_point[0] != '.' ||
+        decimal_point[1] != 0)
+    {
+        /* Look for a '.' in the input; if present, it'll need to be
+           swapped for the current locale's decimal point before we
+           call strtod.  On the other hand, if we find the current
+           locale's decimal point then the input is invalid. */
+        while (Py_ISDIGIT(*p))
+            p++;
+
+        if (*p == '.')
+        {
+            decimal_point_pos = p++;
+
+            /* locate end of number */
+            while (Py_ISDIGIT(*p))
+                p++;
+
+            if (*p == 'e' || *p == 'E')
+                p++;
+            if (*p == '+' || *p == '-')
+                p++;
+            while (Py_ISDIGIT(*p))
+                p++;
+            end = p;
+        }
+        else if (strncmp(p, decimal_point, decimal_point_len) == 0)
+            /* Python bug #1417699 */
+            goto invalid_string;
+        /* For the other cases, we need not convert the decimal
+           point */
+    }
+
+    if (decimal_point_pos) {
+        char *copy, *c;
+        /* Create a copy of the input, with the '.' converted to the
+           locale-specific decimal point */
+        copy = (char *)PyMem_MALLOC(end - digits_pos +
+                                    1 + decimal_point_len);
+        if (copy == NULL) {
+            *endptr = (char *)nptr;
+            errno = ENOMEM;
+            return val;
+        }
+
+        c = copy;
+        memcpy(c, digits_pos, decimal_point_pos - digits_pos);
+        c += decimal_point_pos - digits_pos;
+        memcpy(c, decimal_point, decimal_point_len);
+        c += decimal_point_len;
+        memcpy(c, decimal_point_pos + 1,
+               end - (decimal_point_pos + 1));
+        c += end - (decimal_point_pos + 1);
+        *c = 0;
+
+        val = strtod(copy, &fail_pos);
+
+        if (fail_pos)
+        {
+            if (fail_pos > decimal_point_pos)
+                fail_pos = (char *)digits_pos +
+                    (fail_pos - copy) -
+                    (decimal_point_len - 1);
+            else
+                fail_pos = (char *)digits_pos +
+                    (fail_pos - copy);
+        }
+
+        PyMem_FREE(copy);
+
+    }
+    else {
+        val = strtod(digits_pos, &fail_pos);
+    }
+
+    if (fail_pos == digits_pos)
+        goto invalid_string;
+
+    if (negate && fail_pos != nptr)
+        val = -val;
+    *endptr = fail_pos;
+
+    return val;
 
   invalid_string:
-	*endptr = (char*)nptr;
-	errno = EINVAL;
-	return -1.0;
+    *endptr = (char*)nptr;
+    errno = EINVAL;
+    return -1.0;
 }
 
 #endif
@@ -275,27 +275,27 @@ _PyOS_ascii_strtod(const char *nptr, char **endptr)
 double
 PyOS_ascii_strtod(const char *nptr, char **endptr)
 {
-	char *fail_pos;
-	const char *p;
-	double x;
-
-	if (PyErr_WarnEx(PyExc_DeprecationWarning,
-			 "PyOS_ascii_strtod and PyOS_ascii_atof are "
-			 "deprecated.  Use PyOS_string_to_double "
-			 "instead.", 1) < 0)
-		return -1.0;
-
-	/* _PyOS_ascii_strtod already does everything that we want,
-	   except that it doesn't parse leading whitespace */
-	p = nptr;
-	while (Py_ISSPACE(*p))
-		p++;
-	x = _PyOS_ascii_strtod(p, &fail_pos);
-	if (fail_pos == p)
-		fail_pos = (char *)nptr;
-	if (endptr)
-		*endptr = (char *)fail_pos;
-	return x;
+    char *fail_pos;
+    const char *p;
+    double x;
+
+    if (PyErr_WarnEx(PyExc_DeprecationWarning,
+                     "PyOS_ascii_strtod and PyOS_ascii_atof are "
+                     "deprecated.  Use PyOS_string_to_double "
+                     "instead.", 1) < 0)
+        return -1.0;
+
+    /* _PyOS_ascii_strtod already does everything that we want,
+       except that it doesn't parse leading whitespace */
+    p = nptr;
+    while (Py_ISSPACE(*p))
+        p++;
+    x = _PyOS_ascii_strtod(p, &fail_pos);
+    if (fail_pos == p)
+        fail_pos = (char *)nptr;
+    if (endptr)
+        *endptr = (char *)fail_pos;
+    return x;
 }
 
 /* PyOS_ascii_strtod is DEPRECATED in Python 2.7 and 3.1 */
@@ -303,7 +303,7 @@ PyOS_ascii_strtod(const char *nptr, char **endptr)
 double
 PyOS_ascii_atof(const char *nptr)
 {
-	return PyOS_ascii_strtod(nptr, NULL);
+    return PyOS_ascii_strtod(nptr, NULL);
 }
 
 /* PyOS_string_to_double is the recommended replacement for the deprecated
@@ -334,39 +334,39 @@ PyOS_ascii_atof(const char *nptr)
 
 double
 PyOS_string_to_double(const char *s,
-		      char **endptr,
-		      PyObject *overflow_exception)
+                      char **endptr,
+                      PyObject *overflow_exception)
 {
-	double x, result=-1.0;
-	char *fail_pos;
-
-	errno = 0;
-	PyFPE_START_PROTECT("PyOS_string_to_double", return -1.0)
-	x = _PyOS_ascii_strtod(s, &fail_pos);
-	PyFPE_END_PROTECT(x)
-
-	if (errno == ENOMEM) {
-		PyErr_NoMemory();
-		fail_pos = (char *)s;
-	}
-	else if (!endptr && (fail_pos == s || *fail_pos != '\0'))
-		PyErr_Format(PyExc_ValueError,
-			      "could not convert string to float: "
-			      "%.200s", s);
-	else if (fail_pos == s)
-		PyErr_Format(PyExc_ValueError,
-			      "could not convert string to float: "
-			      "%.200s", s);
-	else if (errno == ERANGE && fabs(x) >= 1.0 && overflow_exception)
-		PyErr_Format(overflow_exception,
-			      "value too large to convert to float: "
-			      "%.200s", s);
-	else
-		result = x;
-
-	if (endptr != NULL)
-		*endptr = fail_pos;
-	return result;
+    double x, result=-1.0;
+    char *fail_pos;
+
+    errno = 0;
+    PyFPE_START_PROTECT("PyOS_string_to_double", return -1.0)
+    x = _PyOS_ascii_strtod(s, &fail_pos);
+    PyFPE_END_PROTECT(x)
+
+    if (errno == ENOMEM) {
+        PyErr_NoMemory();
+        fail_pos = (char *)s;
+    }
+    else if (!endptr && (fail_pos == s || *fail_pos != '\0'))
+        PyErr_Format(PyExc_ValueError,
+                      "could not convert string to float: "
+                      "%.200s", s);
+    else if (fail_pos == s)
+        PyErr_Format(PyExc_ValueError,
+                      "could not convert string to float: "
+                      "%.200s", s);
+    else if (errno == ERANGE && fabs(x) >= 1.0 && overflow_exception)
+        PyErr_Format(overflow_exception,
+                      "value too large to convert to float: "
+                      "%.200s", s);
+    else
+        result = x;
+
+    if (endptr != NULL)
+        *endptr = fail_pos;
+    return result;
 }
 
 /* Given a string that may have a decimal point in the current
@@ -375,30 +375,30 @@ PyOS_string_to_double(const char *s,
 Py_LOCAL_INLINE(void)
 change_decimal_from_locale_to_dot(char* buffer)
 {
-	struct lconv *locale_data = localeconv();
-	const char *decimal_point = locale_data->decimal_point;
-
-	if (decimal_point[0] != '.' || decimal_point[1] != 0) {
-		size_t decimal_point_len = strlen(decimal_point);
-
-		if (*buffer == '+' || *buffer == '-')
-			buffer++;
-		while (Py_ISDIGIT(*buffer))
-			buffer++;
-		if (strncmp(buffer, decimal_point, decimal_point_len) == 0) {
-			*buffer = '.';
-			buffer++;
-			if (decimal_point_len > 1) {
-				/* buffer needs to get smaller */
-				size_t rest_len = strlen(buffer +
-						     (decimal_point_len - 1));
-				memmove(buffer,
-					buffer + (decimal_point_len - 1),
-					rest_len);
-				buffer[rest_len] = 0;
-			}
-		}
-	}
+    struct lconv *locale_data = localeconv();
+    const char *decimal_point = locale_data->decimal_point;
+
+    if (decimal_point[0] != '.' || decimal_point[1] != 0) {
+        size_t decimal_point_len = strlen(decimal_point);
+
+        if (*buffer == '+' || *buffer == '-')
+            buffer++;
+        while (Py_ISDIGIT(*buffer))
+            buffer++;
+        if (strncmp(buffer, decimal_point, decimal_point_len) == 0) {
+            *buffer = '.';
+            buffer++;
+            if (decimal_point_len > 1) {
+                /* buffer needs to get smaller */
+                size_t rest_len = strlen(buffer +
+                                     (decimal_point_len - 1));
+                memmove(buffer,
+                    buffer + (decimal_point_len - 1),
+                    rest_len);
+                buffer[rest_len] = 0;
+            }
+        }
+    }
 }
 
 
@@ -413,65 +413,65 @@ as necessary to represent the exponent.
 Py_LOCAL_INLINE(void)
 ensure_minimum_exponent_length(char* buffer, size_t buf_size)
 {
-	char *p = strpbrk(buffer, "eE");
-	if (p && (*(p + 1) == '-' || *(p + 1) == '+')) {
-		char *start = p + 2;
-		int exponent_digit_cnt = 0;
-		int leading_zero_cnt = 0;
-		int in_leading_zeros = 1;
-		int significant_digit_cnt;
-
-		/* Skip over the exponent and the sign. */
-		p += 2;
-
-		/* Find the end of the exponent, keeping track of leading
-		   zeros. */
-		while (*p && Py_ISDIGIT(*p)) {
-			if (in_leading_zeros && *p == '0')
-				++leading_zero_cnt;
-			if (*p != '0')
-				in_leading_zeros = 0;
-			++p;
-			++exponent_digit_cnt;
-		}
-
-		significant_digit_cnt = exponent_digit_cnt - leading_zero_cnt;
-		if (exponent_digit_cnt == MIN_EXPONENT_DIGITS) {
-			/* If there are 2 exactly digits, we're done,
-			   regardless of what they contain */
-		}
-		else if (exponent_digit_cnt > MIN_EXPONENT_DIGITS) {
-			int extra_zeros_cnt;
-
-			/* There are more than 2 digits in the exponent.  See
-			   if we can delete some of the leading zeros */
-			if (significant_digit_cnt < MIN_EXPONENT_DIGITS)
-				significant_digit_cnt = MIN_EXPONENT_DIGITS;
-			extra_zeros_cnt = exponent_digit_cnt -
-				significant_digit_cnt;
-
-			/* Delete extra_zeros_cnt worth of characters from the
-			   front of the exponent */
-			assert(extra_zeros_cnt >= 0);
-
-			/* Add one to significant_digit_cnt to copy the
-			   trailing 0 byte, thus setting the length */
-			memmove(start,
-				start + extra_zeros_cnt,
-				significant_digit_cnt + 1);
-		}
-		else {
-			/* If there are fewer than 2 digits, add zeros
-			   until there are 2, if there's enough room */
-			int zeros = MIN_EXPONENT_DIGITS - exponent_digit_cnt;
-			if (start + zeros + exponent_digit_cnt + 1
-			      < buffer + buf_size) {
-				memmove(start + zeros, start,
-					exponent_digit_cnt + 1);
-				memset(start, '0', zeros);
-			}
-		}
-	}
+    char *p = strpbrk(buffer, "eE");
+    if (p && (*(p + 1) == '-' || *(p + 1) == '+')) {
+        char *start = p + 2;
+        int exponent_digit_cnt = 0;
+        int leading_zero_cnt = 0;
+        int in_leading_zeros = 1;
+        int significant_digit_cnt;
+
+        /* Skip over the exponent and the sign. */
+        p += 2;
+
+        /* Find the end of the exponent, keeping track of leading
+           zeros. */
+        while (*p && Py_ISDIGIT(*p)) {
+            if (in_leading_zeros && *p == '0')
+                ++leading_zero_cnt;
+            if (*p != '0')
+                in_leading_zeros = 0;
+            ++p;
+            ++exponent_digit_cnt;
+        }
+
+        significant_digit_cnt = exponent_digit_cnt - leading_zero_cnt;
+        if (exponent_digit_cnt == MIN_EXPONENT_DIGITS) {
+            /* If there are 2 exactly digits, we're done,
+               regardless of what they contain */
+        }
+        else if (exponent_digit_cnt > MIN_EXPONENT_DIGITS) {
+            int extra_zeros_cnt;
+
+            /* There are more than 2 digits in the exponent.  See
+               if we can delete some of the leading zeros */
+            if (significant_digit_cnt < MIN_EXPONENT_DIGITS)
+                significant_digit_cnt = MIN_EXPONENT_DIGITS;
+            extra_zeros_cnt = exponent_digit_cnt -
+                significant_digit_cnt;
+
+            /* Delete extra_zeros_cnt worth of characters from the
+               front of the exponent */
+            assert(extra_zeros_cnt >= 0);
+
+            /* Add one to significant_digit_cnt to copy the
+               trailing 0 byte, thus setting the length */
+            memmove(start,
+                start + extra_zeros_cnt,
+                significant_digit_cnt + 1);
+        }
+        else {
+            /* If there are fewer than 2 digits, add zeros
+               until there are 2, if there's enough room */
+            int zeros = MIN_EXPONENT_DIGITS - exponent_digit_cnt;
+            if (start + zeros + exponent_digit_cnt + 1
+                  < buffer + buf_size) {
+                memmove(start + zeros, start,
+                    exponent_digit_cnt + 1);
+                memset(start, '0', zeros);
+            }
+        }
+    }
 }
 
 /* Remove trailing zeros after the decimal point from a numeric string; also
@@ -481,40 +481,40 @@ ensure_minimum_exponent_length(char* buffer, size_t buf_size)
 Py_LOCAL_INLINE(void)
 remove_trailing_zeros(char *buffer)
 {
-	char *old_fraction_end, *new_fraction_end, *end, *p;
-
-	p = buffer;
-	if (*p == '-' || *p == '+')
-		/* Skip leading sign, if present */
-		++p;
-	while (Py_ISDIGIT(*p))
-		++p;
-
-	/* if there's no decimal point there's nothing to do */
-	if (*p++ != '.')
-		return;
-
-	/* scan any digits after the point */
-	while (Py_ISDIGIT(*p))
-		++p;
-	old_fraction_end = p;
-
-	/* scan up to ending '\0' */
-	while (*p != '\0')
-		p++;
-	/* +1 to make sure that we move the null byte as well */
-	end = p+1;
-
-	/* scan back from fraction_end, looking for removable zeros */
-	p = old_fraction_end;
-	while (*(p-1) == '0')
-		--p;
-	/* and remove point if we've got that far */
-	if (*(p-1) == '.')
-		--p;
-	new_fraction_end = p;
-
-	memmove(new_fraction_end, old_fraction_end, end-old_fraction_end);
+    char *old_fraction_end, *new_fraction_end, *end, *p;
+
+    p = buffer;
+    if (*p == '-' || *p == '+')
+        /* Skip leading sign, if present */
+        ++p;
+    while (Py_ISDIGIT(*p))
+        ++p;
+
+    /* if there's no decimal point there's nothing to do */
+    if (*p++ != '.')
+        return;
+
+    /* scan any digits after the point */
+    while (Py_ISDIGIT(*p))
+        ++p;
+    old_fraction_end = p;
+
+    /* scan up to ending '\0' */
+    while (*p != '\0')
+        p++;
+    /* +1 to make sure that we move the null byte as well */
+    end = p+1;
+
+    /* scan back from fraction_end, looking for removable zeros */
+    p = old_fraction_end;
+    while (*(p-1) == '0')
+        --p;
+    /* and remove point if we've got that far */
+    if (*(p-1) == '.')
+        --p;
+    new_fraction_end = p;
+
+    memmove(new_fraction_end, old_fraction_end, end-old_fraction_end);
 }
 
 /* Ensure that buffer has a decimal point in it.  The decimal point will not
@@ -527,91 +527,91 @@ remove_trailing_zeros(char *buffer)
 Py_LOCAL_INLINE(char *)
 ensure_decimal_point(char* buffer, size_t buf_size, int precision)
 {
-	int digit_count, insert_count = 0, convert_to_exp = 0;
-	char *chars_to_insert, *digits_start;
-
-	/* search for the first non-digit character */
-	char *p = buffer;
-	if (*p == '-' || *p == '+')
-		/* Skip leading sign, if present.  I think this could only
-		   ever be '-', but it can't hurt to check for both. */
-		++p;
-	digits_start = p;
-	while (*p && Py_ISDIGIT(*p))
-		++p;
-	digit_count = Py_SAFE_DOWNCAST(p - digits_start, Py_ssize_t, int);
-
-	if (*p == '.') {
-		if (Py_ISDIGIT(*(p+1))) {
-			/* Nothing to do, we already have a decimal
-			   point and a digit after it */
-		}
-		else {
-			/* We have a decimal point, but no following
-			   digit.  Insert a zero after the decimal. */
-			/* can't ever get here via PyOS_double_to_string */
-			assert(precision == -1);
-			++p;
-			chars_to_insert = "0";
-			insert_count = 1;
-		}
-	}
-	else if (!(*p == 'e' || *p == 'E')) {
-		/* Don't add ".0" if we have an exponent. */
-		if (digit_count == precision) {
-			/* issue 5864: don't add a trailing .0 in the case
-			   where the '%g'-formatted result already has as many
-			   significant digits as were requested.  Switch to
-			   exponential notation instead. */
-			convert_to_exp = 1;
-			/* no exponent, no point, and we shouldn't land here
-			   for infs and nans, so we must be at the end of the
-			   string. */
-			assert(*p == '\0');
-		}
-		else {
-			assert(precision == -1 || digit_count < precision);
-			chars_to_insert = ".0";
-			insert_count = 2;
-		}
-	}
-	if (insert_count) {
-		size_t buf_len = strlen(buffer);
-		if (buf_len + insert_count + 1 >= buf_size) {
-			/* If there is not enough room in the buffer
-			   for the additional text, just skip it.  It's
-			   not worth generating an error over. */
-		}
-		else {
-			memmove(p + insert_count, p,
-				buffer + strlen(buffer) - p + 1);
-			memcpy(p, chars_to_insert, insert_count);
-		}
-	}
-	if (convert_to_exp) {
-		int written;
-		size_t buf_avail;
-		p = digits_start;
-		/* insert decimal point */
-		assert(digit_count >= 1);
-		memmove(p+2, p+1, digit_count); /* safe, but overwrites nul */
-		p[1] = '.';
-		p += digit_count+1;
-		assert(p <= buf_size+buffer);
-		buf_avail = buf_size+buffer-p;
-		if (buf_avail == 0)
-			return NULL;
-		/* Add exponent.  It's okay to use lower case 'e': we only
-		   arrive here as a result of using the empty format code or
-		   repr/str builtins and those never want an upper case 'E' */
-		written = PyOS_snprintf(p, buf_avail, "e%+.02d", digit_count-1);
-		if (!(0 <= written &&
-		      written < Py_SAFE_DOWNCAST(buf_avail, size_t, int)))
-			/* output truncated, or something else bad happened */
-			return NULL;
-		remove_trailing_zeros(buffer);
-	}
-	return buffer;
+    int digit_count, insert_count = 0, convert_to_exp = 0;
+    char *chars_to_insert, *digits_start;
+
+    /* search for the first non-digit character */
+    char *p = buffer;
+    if (*p == '-' || *p == '+')
+        /* Skip leading sign, if present.  I think this could only
+           ever be '-', but it can't hurt to check for both. */
+        ++p;
+    digits_start = p;
+    while (*p && Py_ISDIGIT(*p))
+        ++p;
+    digit_count = Py_SAFE_DOWNCAST(p - digits_start, Py_ssize_t, int);
+
+    if (*p == '.') {
+        if (Py_ISDIGIT(*(p+1))) {
+            /* Nothing to do, we already have a decimal
+               point and a digit after it */
+        }
+        else {
+            /* We have a decimal point, but no following
+               digit.  Insert a zero after the decimal. */
+            /* can't ever get here via PyOS_double_to_string */
+            assert(precision == -1);
+            ++p;
+            chars_to_insert = "0";
+            insert_count = 1;
+        }
+    }
+    else if (!(*p == 'e' || *p == 'E')) {
+        /* Don't add ".0" if we have an exponent. */
+        if (digit_count == precision) {
+            /* issue 5864: don't add a trailing .0 in the case
+               where the '%g'-formatted result already has as many
+               significant digits as were requested.  Switch to
+               exponential notation instead. */
+            convert_to_exp = 1;
+            /* no exponent, no point, and we shouldn't land here
+               for infs and nans, so we must be at the end of the
+               string. */
+            assert(*p == '\0');
+        }
+        else {
+            assert(precision == -1 || digit_count < precision);
+            chars_to_insert = ".0";
+            insert_count = 2;
+        }
+    }
+    if (insert_count) {
+        size_t buf_len = strlen(buffer);
+        if (buf_len + insert_count + 1 >= buf_size) {
+            /* If there is not enough room in the buffer
+               for the additional text, just skip it.  It's
+               not worth generating an error over. */
+        }
+        else {
+            memmove(p + insert_count, p,
+                buffer + strlen(buffer) - p + 1);
+            memcpy(p, chars_to_insert, insert_count);
+        }
+    }
+    if (convert_to_exp) {
+        int written;
+        size_t buf_avail;
+        p = digits_start;
+        /* insert decimal point */
+        assert(digit_count >= 1);
+        memmove(p+2, p+1, digit_count); /* safe, but overwrites nul */
+        p[1] = '.';
+        p += digit_count+1;
+        assert(p <= buf_size+buffer);
+        buf_avail = buf_size+buffer-p;
+        if (buf_avail == 0)
+            return NULL;
+        /* Add exponent.  It's okay to use lower case 'e': we only
+           arrive here as a result of using the empty format code or
+           repr/str builtins and those never want an upper case 'E' */
+        written = PyOS_snprintf(p, buf_avail, "e%+.02d", digit_count-1);
+        if (!(0 <= written &&
+              written < Py_SAFE_DOWNCAST(buf_avail, size_t, int)))
+            /* output truncated, or something else bad happened */
+            return NULL;
+        remove_trailing_zeros(buffer);
+    }
+    return buffer;
 }
 
 /* see FORMATBUFLEN in unicodeobject.c */
@@ -622,14 +622,14 @@ ensure_decimal_point(char* buffer, size_t buf_size, int precision)
  * @buffer: A buffer to place the resulting string in
  * @buf_size: The length of the buffer.
  * @format: The printf()-style format to use for the
- *          code to use for converting. 
+ *          code to use for converting.
  * @d: The #gdouble to convert
  *
  * Converts a #gdouble to a string, using the '.' as
  * decimal point. To format the number you pass in
  * a printf()-style format string. Allowed conversion
  * specifiers are 'e', 'E', 'f', 'F', 'g', 'G', and 'Z'.
- * 
+ *
  * 'Z' is the same as 'g', except it always has a decimal and
  *     at least one digit after the decimal.
  *
@@ -637,97 +637,97 @@ ensure_decimal_point(char* buffer, size_t buf_size, int precision)
  * On failure returns NULL but does not set any Python exception.
  **/
 char *
-_PyOS_ascii_formatd(char       *buffer, 
-		   size_t      buf_size, 
-		   const char *format, 
-		   double      d, 
-		   int         precision)
+_PyOS_ascii_formatd(char       *buffer,
+                   size_t      buf_size,
+                   const char *format,
+                   double      d,
+                   int         precision)
 {
-	char format_char;
-	size_t format_len = strlen(format);
-
-	/* Issue 2264: code 'Z' requires copying the format.  'Z' is 'g', but
-	   also with at least one character past the decimal. */
-	char tmp_format[FLOAT_FORMATBUFLEN];
-
-	/* The last character in the format string must be the format char */
-	format_char = format[format_len - 1];
-
-	if (format[0] != '%')
-		return NULL;
-
-	/* I'm not sure why this test is here.  It's ensuring that the format
-	   string after the first character doesn't have a single quote, a
-	   lowercase l, or a percent. This is the reverse of the commented-out
-	   test about 10 lines ago. */
-	if (strpbrk(format + 1, "'l%"))
-		return NULL;
-
-	/* Also curious about this function is that it accepts format strings
-	   like "%xg", which are invalid for floats.  In general, the
-	   interface to this function is not very good, but changing it is
-	   difficult because it's a public API. */
-
-	if (!(format_char == 'e' || format_char == 'E' || 
-	      format_char == 'f' || format_char == 'F' || 
-	      format_char == 'g' || format_char == 'G' ||
-	      format_char == 'Z'))
-		return NULL;
-
-	/* Map 'Z' format_char to 'g', by copying the format string and
-	   replacing the final char with a 'g' */
-	if (format_char == 'Z') {
-		if (format_len + 1 >= sizeof(tmp_format)) {
-			/* The format won't fit in our copy.  Error out.  In
-			   practice, this will never happen and will be
-			   detected by returning NULL */
-			return NULL;
-		}
-		strcpy(tmp_format, format);
-		tmp_format[format_len - 1] = 'g';
-		format = tmp_format;
-	}
-
-
-	/* Have PyOS_snprintf do the hard work */
-	PyOS_snprintf(buffer, buf_size, format, d);
-
-	/* Do various fixups on the return string */
-
-	/* Get the current locale, and find the decimal point string.
-	   Convert that string back to a dot. */
-	change_decimal_from_locale_to_dot(buffer);
-
-	/* If an exponent exists, ensure that the exponent is at least
-	   MIN_EXPONENT_DIGITS digits, providing the buffer is large enough
-	   for the extra zeros.  Also, if there are more than
-	   MIN_EXPONENT_DIGITS, remove as many zeros as possible until we get
-	   back to MIN_EXPONENT_DIGITS */
-	ensure_minimum_exponent_length(buffer, buf_size);
-
-	/* If format_char is 'Z', make sure we have at least one character
-	   after the decimal point (and make sure we have a decimal point);
-	   also switch to exponential notation in some edge cases where the
-	   extra character would produce more significant digits that we
-	   really want. */
-	if (format_char == 'Z')
-		buffer = ensure_decimal_point(buffer, buf_size, precision);
-
-	return buffer;
+    char format_char;
+    size_t format_len = strlen(format);
+
+    /* Issue 2264: code 'Z' requires copying the format.  'Z' is 'g', but
+       also with at least one character past the decimal. */
+    char tmp_format[FLOAT_FORMATBUFLEN];
+
+    /* The last character in the format string must be the format char */
+    format_char = format[format_len - 1];
+
+    if (format[0] != '%')
+        return NULL;
+
+    /* I'm not sure why this test is here.  It's ensuring that the format
+       string after the first character doesn't have a single quote, a
+       lowercase l, or a percent. This is the reverse of the commented-out
+       test about 10 lines ago. */
+    if (strpbrk(format + 1, "'l%"))
+        return NULL;
+
+    /* Also curious about this function is that it accepts format strings
+       like "%xg", which are invalid for floats.  In general, the
+       interface to this function is not very good, but changing it is
+       difficult because it's a public API. */
+
+    if (!(format_char == 'e' || format_char == 'E' ||
+          format_char == 'f' || format_char == 'F' ||
+          format_char == 'g' || format_char == 'G' ||
+          format_char == 'Z'))
+        return NULL;
+
+    /* Map 'Z' format_char to 'g', by copying the format string and
+       replacing the final char with a 'g' */
+    if (format_char == 'Z') {
+        if (format_len + 1 >= sizeof(tmp_format)) {
+            /* The format won't fit in our copy.  Error out.  In
+               practice, this will never happen and will be
+               detected by returning NULL */
+            return NULL;
+        }
+        strcpy(tmp_format, format);
+        tmp_format[format_len - 1] = 'g';
+        format = tmp_format;
+    }
+
+
+    /* Have PyOS_snprintf do the hard work */
+    PyOS_snprintf(buffer, buf_size, format, d);
+
+    /* Do various fixups on the return string */
+
+    /* Get the current locale, and find the decimal point string.
+       Convert that string back to a dot. */
+    change_decimal_from_locale_to_dot(buffer);
+
+    /* If an exponent exists, ensure that the exponent is at least
+       MIN_EXPONENT_DIGITS digits, providing the buffer is large enough
+       for the extra zeros.  Also, if there are more than
+       MIN_EXPONENT_DIGITS, remove as many zeros as possible until we get
+       back to MIN_EXPONENT_DIGITS */
+    ensure_minimum_exponent_length(buffer, buf_size);
+
+    /* If format_char is 'Z', make sure we have at least one character
+       after the decimal point (and make sure we have a decimal point);
+       also switch to exponential notation in some edge cases where the
+       extra character would produce more significant digits that we
+       really want. */
+    if (format_char == 'Z')
+        buffer = ensure_decimal_point(buffer, buf_size, precision);
+
+    return buffer;
 }
 
 char *
-PyOS_ascii_formatd(char       *buffer, 
-		   size_t      buf_size, 
-		   const char *format, 
-		   double      d)
+PyOS_ascii_formatd(char       *buffer,
+                   size_t      buf_size,
+                   const char *format,
+                   double      d)
 {
-	if (PyErr_WarnEx(PyExc_DeprecationWarning,
-			 "PyOS_ascii_formatd is deprecated, "
-			 "use PyOS_double_to_string instead", 1) < 0)
-		return NULL;
+    if (PyErr_WarnEx(PyExc_DeprecationWarning,
+                     "PyOS_ascii_formatd is deprecated, "
+                     "use PyOS_double_to_string instead", 1) < 0)
+        return NULL;
 
-	return _PyOS_ascii_formatd(buffer, buf_size, format, d, -1);
+    return _PyOS_ascii_formatd(buffer, buf_size, format, d, -1);
 }
 
 #ifdef PY_NO_SHORT_FLOAT_REPR
@@ -740,146 +740,146 @@ PyAPI_FUNC(char *) PyOS_double_to_string(double val,
                                          int flags,
                                          int *type)
 {
-	char format[32];
-	Py_ssize_t bufsize;
-	char *buf;
-	int t, exp;
-	int upper = 0;
-
-	/* Validate format_code, and map upper and lower case */
-	switch (format_code) {
-	case 'e':          /* exponent */
-	case 'f':          /* fixed */
-	case 'g':          /* general */
-		break;
-	case 'E':
-		upper = 1;
-		format_code = 'e';
-		break;
-	case 'F':
-		upper = 1;
-		format_code = 'f';
-		break;
-	case 'G':
-		upper = 1;
-		format_code = 'g';
-		break;
-	case 'r':          /* repr format */
-		/* Supplied precision is unused, must be 0. */
-		if (precision != 0) {
-			PyErr_BadInternalCall();
-			return NULL;
-		}
-		/* The repr() precision (17 significant decimal digits) is the
-		   minimal number that is guaranteed to have enough precision
-		   so that if the number is read back in the exact same binary
-		   value is recreated.  This is true for IEEE floating point
-		   by design, and also happens to work for all other modern
-		   hardware. */
-		precision = 17;
-		format_code = 'g';
-		break;
-	default:
-		PyErr_BadInternalCall();
-		return NULL;
-	}
-
-	/* Here's a quick-and-dirty calculation to figure out how big a buffer
-	   we need.  In general, for a finite float we need:
-
-	     1 byte for each digit of the decimal significand, and
-
-	     1 for a possible sign
-	     1 for a possible decimal point
-	     2 for a possible [eE][+-]
-	     1 for each digit of the exponent;  if we allow 19 digits
-	       total then we're safe up to exponents of 2**63.
-	     1 for the trailing nul byte
-
-	   This gives a total of 24 + the number of digits in the significand,
-	   and the number of digits in the significand is:
-
-	     for 'g' format: at most precision, except possibly
-	       when precision == 0, when it's 1.
-	     for 'e' format: precision+1
-	     for 'f' format: precision digits after the point, at least 1
-	       before.  To figure out how many digits appear before the point
-	       we have to examine the size of the number.  If fabs(val) < 1.0
-	       then there will be only one digit before the point.  If
-	       fabs(val) >= 1.0, then there are at most
-
-	         1+floor(log10(ceiling(fabs(val))))
-
-	       digits before the point (where the 'ceiling' allows for the
-	       possibility that the rounding rounds the integer part of val
-	       up).  A safe upper bound for the above quantity is
-	       1+floor(exp/3), where exp is the unique integer such that 0.5
-	       <= fabs(val)/2**exp < 1.0.  This exp can be obtained from
-	       frexp.
-
-	   So we allow room for precision+1 digits for all formats, plus an
-	   extra floor(exp/3) digits for 'f' format.
-
-	*/
-
-	if (Py_IS_NAN(val) || Py_IS_INFINITY(val))
-		/* 3 for 'inf'/'nan', 1 for sign, 1 for '\0' */
-		bufsize = 5;
-	else {
-		bufsize = 25 + precision;
-		if (format_code == 'f' && fabs(val) >= 1.0) {
-			frexp(val, &exp);
-			bufsize += exp/3;
-		}
-	}
-
-	buf = PyMem_Malloc(bufsize);
-	if (buf == NULL) {
-		PyErr_NoMemory();
-		return NULL;
-	}
-
-	/* Handle nan and inf. */
-	if (Py_IS_NAN(val)) {
-		strcpy(buf, "nan");
-		t = Py_DTST_NAN;
-	} else if (Py_IS_INFINITY(val)) {
-		if (copysign(1., val) == 1.)
-			strcpy(buf, "inf");
-		else
-			strcpy(buf, "-inf");
-		t = Py_DTST_INFINITE;
-	} else {
-		t = Py_DTST_FINITE;
-		if (flags & Py_DTSF_ADD_DOT_0)
-			format_code = 'Z';
-
-		PyOS_snprintf(format, sizeof(format), "%%%s.%i%c",
-			      (flags & Py_DTSF_ALT ? "#" : ""), precision,
-			      format_code);
-		_PyOS_ascii_formatd(buf, bufsize, format, val, precision);
-	}
-
-	/* Add sign when requested.  It's convenient (esp. when formatting
-	 complex numbers) to include a sign even for inf and nan. */
-	if (flags & Py_DTSF_SIGN && buf[0] != '-') {
-		size_t len = strlen(buf);
-		/* the bufsize calculations above should ensure that we've got
-		   space to add a sign */
-		assert((size_t)bufsize >= len+2);
-		memmove(buf+1, buf, len+1);
-		buf[0] = '+';
-	}
-	if (upper) {
-		/* Convert to upper case. */
-		char *p1;
-		for (p1 = buf; *p1; p1++)
-			*p1 = Py_TOUPPER(*p1);
-	}
-
-	if (type)
-		*type = t;
-	return buf;
+    char format[32];
+    Py_ssize_t bufsize;
+    char *buf;
+    int t, exp;
+    int upper = 0;
+
+    /* Validate format_code, and map upper and lower case */
+    switch (format_code) {
+    case 'e':          /* exponent */
+    case 'f':          /* fixed */
+    case 'g':          /* general */
+        break;
+    case 'E':
+        upper = 1;
+        format_code = 'e';
+        break;
+    case 'F':
+        upper = 1;
+        format_code = 'f';
+        break;
+    case 'G':
+        upper = 1;
+        format_code = 'g';
+        break;
+    case 'r':          /* repr format */
+        /* Supplied precision is unused, must be 0. */
+        if (precision != 0) {
+            PyErr_BadInternalCall();
+            return NULL;
+        }
+        /* The repr() precision (17 significant decimal digits) is the
+           minimal number that is guaranteed to have enough precision
+           so that if the number is read back in the exact same binary
+           value is recreated.  This is true for IEEE floating point
+           by design, and also happens to work for all other modern
+           hardware. */
+        precision = 17;
+        format_code = 'g';
+        break;
+    default:
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+
+    /* Here's a quick-and-dirty calculation to figure out how big a buffer
+       we need.  In general, for a finite float we need:
+
+         1 byte for each digit of the decimal significand, and
+
+         1 for a possible sign
+         1 for a possible decimal point
+         2 for a possible [eE][+-]
+         1 for each digit of the exponent;  if we allow 19 digits
+           total then we're safe up to exponents of 2**63.
+         1 for the trailing nul byte
+
+       This gives a total of 24 + the number of digits in the significand,
+       and the number of digits in the significand is:
+
+         for 'g' format: at most precision, except possibly
+           when precision == 0, when it's 1.
+         for 'e' format: precision+1
+         for 'f' format: precision digits after the point, at least 1
+           before.  To figure out how many digits appear before the point
+           we have to examine the size of the number.  If fabs(val) < 1.0
+           then there will be only one digit before the point.  If
+           fabs(val) >= 1.0, then there are at most
+
+         1+floor(log10(ceiling(fabs(val))))
+
+           digits before the point (where the 'ceiling' allows for the
+           possibility that the rounding rounds the integer part of val
+           up).  A safe upper bound for the above quantity is
+           1+floor(exp/3), where exp is the unique integer such that 0.5
+           <= fabs(val)/2**exp < 1.0.  This exp can be obtained from
+           frexp.
+
+       So we allow room for precision+1 digits for all formats, plus an
+       extra floor(exp/3) digits for 'f' format.
+
+    */
+
+    if (Py_IS_NAN(val) || Py_IS_INFINITY(val))
+        /* 3 for 'inf'/'nan', 1 for sign, 1 for '\0' */
+        bufsize = 5;
+    else {
+        bufsize = 25 + precision;
+        if (format_code == 'f' && fabs(val) >= 1.0) {
+            frexp(val, &exp);
+            bufsize += exp/3;
+        }
+    }
+
+    buf = PyMem_Malloc(bufsize);
+    if (buf == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    /* Handle nan and inf. */
+    if (Py_IS_NAN(val)) {
+        strcpy(buf, "nan");
+        t = Py_DTST_NAN;
+    } else if (Py_IS_INFINITY(val)) {
+        if (copysign(1., val) == 1.)
+            strcpy(buf, "inf");
+        else
+            strcpy(buf, "-inf");
+        t = Py_DTST_INFINITE;
+    } else {
+        t = Py_DTST_FINITE;
+        if (flags & Py_DTSF_ADD_DOT_0)
+            format_code = 'Z';
+
+        PyOS_snprintf(format, sizeof(format), "%%%s.%i%c",
+                      (flags & Py_DTSF_ALT ? "#" : ""), precision,
+                      format_code);
+        _PyOS_ascii_formatd(buf, bufsize, format, val, precision);
+    }
+
+    /* Add sign when requested.  It's convenient (esp. when formatting
+     complex numbers) to include a sign even for inf and nan. */
+    if (flags & Py_DTSF_SIGN && buf[0] != '-') {
+        size_t len = strlen(buf);
+        /* the bufsize calculations above should ensure that we've got
+           space to add a sign */
+        assert((size_t)bufsize >= len+2);
+        memmove(buf+1, buf, len+1);
+        buf[0] = '+';
+    }
+    if (upper) {
+        /* Convert to upper case. */
+        char *p1;
+        for (p1 = buf; *p1; p1++)
+            *p1 = Py_TOUPPER(*p1);
+    }
+
+    if (type)
+        *type = t;
+    return buf;
 }
 
 #else
@@ -894,14 +894,14 @@ PyAPI_FUNC(char *) PyOS_double_to_string(double val,
 
 /* The lengths of these are known to the code below, so don't change them */
 static char *lc_float_strings[] = {
-	"inf",
-	"nan",
-	"e",
+    "inf",
+    "nan",
+    "e",
 };
 static char *uc_float_strings[] = {
-	"INF",
-	"NAN",
-	"E",
+    "INF",
+    "NAN",
+    "E",
 };
 
 
@@ -925,9 +925,9 @@ static char *uc_float_strings[] = {
        be nonzero.
      type, if non-NULL, will be set to one of these constants to identify
        the type of the 'd' argument:
-         Py_DTST_FINITE
-         Py_DTST_INFINITE
-         Py_DTST_NAN
+     Py_DTST_FINITE
+     Py_DTST_INFINITE
+     Py_DTST_NAN
 
    Returns a PyMem_Malloc'd block of memory containing the resulting string,
     or NULL on error. If NULL is returned, the Python error has been set.
@@ -935,315 +935,315 @@ static char *uc_float_strings[] = {
 
 static char *
 format_float_short(double d, char format_code,
-		   int mode, Py_ssize_t precision,
-		   int always_add_sign, int add_dot_0_if_integer,
-		   int use_alt_formatting, char **float_strings, int *type)
+                   int mode, Py_ssize_t precision,
+                   int always_add_sign, int add_dot_0_if_integer,
+                   int use_alt_formatting, char **float_strings, int *type)
 {
-	char *buf = NULL;
-	char *p = NULL;
-	Py_ssize_t bufsize = 0;
-	char *digits, *digits_end;
-	int decpt_as_int, sign, exp_len, exp = 0, use_exp = 0;
-	Py_ssize_t decpt, digits_len, vdigits_start, vdigits_end;
-	_Py_SET_53BIT_PRECISION_HEADER;
-
-	/* _Py_dg_dtoa returns a digit string (no decimal point or exponent).
-	   Must be matched by a call to _Py_dg_freedtoa. */
-	_Py_SET_53BIT_PRECISION_START;
-	digits = _Py_dg_dtoa(d, mode, precision, &decpt_as_int, &sign,
-			     &digits_end);
-	_Py_SET_53BIT_PRECISION_END;
-
-	decpt = (Py_ssize_t)decpt_as_int;
-	if (digits == NULL) {
-		/* The only failure mode is no memory. */
-		PyErr_NoMemory();
-		goto exit;
-	}
-	assert(digits_end != NULL && digits_end >= digits);
-	digits_len = digits_end - digits;
-
-	if (digits_len && !Py_ISDIGIT(digits[0])) {
-		/* Infinities and nans here; adapt Gay's output,
-		   so convert Infinity to inf and NaN to nan, and
-		   ignore sign of nan. Then return. */
-
-		/* ignore the actual sign of a nan */
-		if (digits[0] == 'n' || digits[0] == 'N')
-			sign = 0;
-
-		/* We only need 5 bytes to hold the result "+inf\0" . */
-		bufsize = 5; /* Used later in an assert. */
-		buf = (char *)PyMem_Malloc(bufsize);
-		if (buf == NULL) {
-			PyErr_NoMemory();
-			goto exit;
-		}
-		p = buf;
-
-		if (sign == 1) {
-			*p++ = '-';
-		}
-		else if (always_add_sign) {
-			*p++ = '+';
-		}
-		if (digits[0] == 'i' || digits[0] == 'I') {
-			strncpy(p, float_strings[OFS_INF], 3);
-			p += 3;
-
-			if (type)
-				*type = Py_DTST_INFINITE;
-		}
-		else if (digits[0] == 'n' || digits[0] == 'N') {
-			strncpy(p, float_strings[OFS_NAN], 3);
-			p += 3;
-
-			if (type)
-				*type = Py_DTST_NAN;
-		}
-		else {
-			/* shouldn't get here: Gay's code should always return
-			   something starting with a digit, an 'I',  or 'N' */
-			strncpy(p, "ERR", 3);
-			p += 3;
-			assert(0);
-		}
-		goto exit;
-	}
-
-	/* The result must be finite (not inf or nan). */
-	if (type)
-		*type = Py_DTST_FINITE;
-
-
-	/* We got digits back, format them.  We may need to pad 'digits'
-	   either on the left or right (or both) with extra zeros, so in
-	   general the resulting string has the form
-
-	     [<sign>]<zeros><digits><zeros>[<exponent>]
-
-	   where either of the <zeros> pieces could be empty, and there's a
-	   decimal point that could appear either in <digits> or in the
-	   leading or trailing <zeros>.
-
-	   Imagine an infinite 'virtual' string vdigits, consisting of the
-	   string 'digits' (starting at index 0) padded on both the left and
-	   right with infinite strings of zeros.  We want to output a slice
-
-	     vdigits[vdigits_start : vdigits_end]
-
-	   of this virtual string.  Thus if vdigits_start < 0 then we'll end
-	   up producing some leading zeros; if vdigits_end > digits_len there
-	   will be trailing zeros in the output.  The next section of code
-	   determines whether to use an exponent or not, figures out the
-	   position 'decpt' of the decimal point, and computes 'vdigits_start'
-	   and 'vdigits_end'. */
-	vdigits_end = digits_len;
-	switch (format_code) {
-	case 'e':
-		use_exp = 1;
-		vdigits_end = precision;
-		break;
-	case 'f':
-		vdigits_end = decpt + precision;
-		break;
-	case 'g':
-		if (decpt <= -4 || decpt >
-		    (add_dot_0_if_integer ? precision-1 : precision))
-			use_exp = 1;
-		if (use_alt_formatting)
-			vdigits_end = precision;
-		break;
-	case 'r':
-		/* convert to exponential format at 1e16.  We used to convert
-		   at 1e17, but that gives odd-looking results for some values
-		   when a 16-digit 'shortest' repr is padded with bogus zeros.
-		   For example, repr(2e16+8) would give 20000000000000010.0;
-		   the true value is 20000000000000008.0. */
-		if (decpt <= -4 || decpt > 16)
-			use_exp = 1;
-		break;
-	default:
-		PyErr_BadInternalCall();
-		goto exit;
-	}
-
-	/* if using an exponent, reset decimal point position to 1 and adjust
-	   exponent accordingly.*/
-	if (use_exp) {
-		exp = decpt - 1;
-		decpt = 1;
-	}
-	/* ensure vdigits_start < decpt <= vdigits_end, or vdigits_start <
-	   decpt < vdigits_end if add_dot_0_if_integer and no exponent */
-	vdigits_start = decpt <= 0 ? decpt-1 : 0;
-	if (!use_exp && add_dot_0_if_integer)
-		vdigits_end = vdigits_end > decpt ? vdigits_end : decpt + 1;
-	else
-		vdigits_end = vdigits_end > decpt ? vdigits_end : decpt;
-
-	/* double check inequalities */
-	assert(vdigits_start <= 0 &&
-	       0 <= digits_len &&
-	       digits_len <= vdigits_end);
-	/* decimal point should be in (vdigits_start, vdigits_end] */
-	assert(vdigits_start < decpt && decpt <= vdigits_end);
-
-	/* Compute an upper bound how much memory we need. This might be a few
-	   chars too long, but no big deal. */
-	bufsize =
-		/* sign, decimal point and trailing 0 byte */
-		3 +
-
-		/* total digit count (including zero padding on both sides) */
-		(vdigits_end - vdigits_start) +
-
-		/* exponent "e+100", max 3 numerical digits */
-		(use_exp ? 5 : 0);
-
-	/* Now allocate the memory and initialize p to point to the start of
-	   it. */
-	buf = (char *)PyMem_Malloc(bufsize);
-	if (buf == NULL) {
-		PyErr_NoMemory();
-		goto exit;
-	}
-	p = buf;
-
-	/* Add a negative sign if negative, and a plus sign if non-negative
-	   and always_add_sign is true. */
-	if (sign == 1)
-		*p++ = '-';
-	else if (always_add_sign)
-		*p++ = '+';
-
-	/* note that exactly one of the three 'if' conditions is true,
-	   so we include exactly one decimal point */
-	/* Zero padding on left of digit string */
-	if (decpt <= 0) {
-		memset(p, '0', decpt-vdigits_start);
-		p += decpt - vdigits_start;
-		*p++ = '.';
-		memset(p, '0', 0-decpt);
-		p += 0-decpt;
-	}
-	else {
-		memset(p, '0', 0-vdigits_start);
-		p += 0 - vdigits_start;
-	}
-
-	/* Digits, with included decimal point */
-	if (0 < decpt && decpt <= digits_len) {
-		strncpy(p, digits, decpt-0);
-		p += decpt-0;
-		*p++ = '.';
-		strncpy(p, digits+decpt, digits_len-decpt);
-		p += digits_len-decpt;
-	}
-	else {
-		strncpy(p, digits, digits_len);
-		p += digits_len;
-	}
-
-	/* And zeros on the right */
-	if (digits_len < decpt) {
-		memset(p, '0', decpt-digits_len);
-		p += decpt-digits_len;
-		*p++ = '.';
-		memset(p, '0', vdigits_end-decpt);
-		p += vdigits_end-decpt;
-	}
-	else {
-		memset(p, '0', vdigits_end-digits_len);
-		p += vdigits_end-digits_len;
-	}
-
-	/* Delete a trailing decimal pt unless using alternative formatting. */
-	if (p[-1] == '.' && !use_alt_formatting)
-		p--;
-
-	/* Now that we've done zero padding, add an exponent if needed. */
-	if (use_exp) {
-		*p++ = float_strings[OFS_E][0];
-		exp_len = sprintf(p, "%+.02d", exp);
-		p += exp_len;
-	}
+    char *buf = NULL;
+    char *p = NULL;
+    Py_ssize_t bufsize = 0;
+    char *digits, *digits_end;
+    int decpt_as_int, sign, exp_len, exp = 0, use_exp = 0;
+    Py_ssize_t decpt, digits_len, vdigits_start, vdigits_end;
+    _Py_SET_53BIT_PRECISION_HEADER;
+
+    /* _Py_dg_dtoa returns a digit string (no decimal point or exponent).
+       Must be matched by a call to _Py_dg_freedtoa. */
+    _Py_SET_53BIT_PRECISION_START;
+    digits = _Py_dg_dtoa(d, mode, precision, &decpt_as_int, &sign,
+                         &digits_end);
+    _Py_SET_53BIT_PRECISION_END;
+
+    decpt = (Py_ssize_t)decpt_as_int;
+    if (digits == NULL) {
+        /* The only failure mode is no memory. */
+        PyErr_NoMemory();
+        goto exit;
+    }
+    assert(digits_end != NULL && digits_end >= digits);
+    digits_len = digits_end - digits;
+
+    if (digits_len && !Py_ISDIGIT(digits[0])) {
+        /* Infinities and nans here; adapt Gay's output,
+           so convert Infinity to inf and NaN to nan, and
+           ignore sign of nan. Then return. */
+
+        /* ignore the actual sign of a nan */
+        if (digits[0] == 'n' || digits[0] == 'N')
+            sign = 0;
+
+        /* We only need 5 bytes to hold the result "+inf\0" . */
+        bufsize = 5; /* Used later in an assert. */
+        buf = (char *)PyMem_Malloc(bufsize);
+        if (buf == NULL) {
+            PyErr_NoMemory();
+            goto exit;
+        }
+        p = buf;
+
+        if (sign == 1) {
+            *p++ = '-';
+        }
+        else if (always_add_sign) {
+            *p++ = '+';
+        }
+        if (digits[0] == 'i' || digits[0] == 'I') {
+            strncpy(p, float_strings[OFS_INF], 3);
+            p += 3;
+
+            if (type)
+                *type = Py_DTST_INFINITE;
+        }
+        else if (digits[0] == 'n' || digits[0] == 'N') {
+            strncpy(p, float_strings[OFS_NAN], 3);
+            p += 3;
+
+            if (type)
+                *type = Py_DTST_NAN;
+        }
+        else {
+            /* shouldn't get here: Gay's code should always return
+               something starting with a digit, an 'I',  or 'N' */
+            strncpy(p, "ERR", 3);
+            p += 3;
+            assert(0);
+        }
+        goto exit;
+    }
+
+    /* The result must be finite (not inf or nan). */
+    if (type)
+        *type = Py_DTST_FINITE;
+
+
+    /* We got digits back, format them.  We may need to pad 'digits'
+       either on the left or right (or both) with extra zeros, so in
+       general the resulting string has the form
+
+         [<sign>]<zeros><digits><zeros>[<exponent>]
+
+       where either of the <zeros> pieces could be empty, and there's a
+       decimal point that could appear either in <digits> or in the
+       leading or trailing <zeros>.
+
+       Imagine an infinite 'virtual' string vdigits, consisting of the
+       string 'digits' (starting at index 0) padded on both the left and
+       right with infinite strings of zeros.  We want to output a slice
+
+         vdigits[vdigits_start : vdigits_end]
+
+       of this virtual string.  Thus if vdigits_start < 0 then we'll end
+       up producing some leading zeros; if vdigits_end > digits_len there
+       will be trailing zeros in the output.  The next section of code
+       determines whether to use an exponent or not, figures out the
+       position 'decpt' of the decimal point, and computes 'vdigits_start'
+       and 'vdigits_end'. */
+    vdigits_end = digits_len;
+    switch (format_code) {
+    case 'e':
+        use_exp = 1;
+        vdigits_end = precision;
+        break;
+    case 'f':
+        vdigits_end = decpt + precision;
+        break;
+    case 'g':
+        if (decpt <= -4 || decpt >
+            (add_dot_0_if_integer ? precision-1 : precision))
+            use_exp = 1;
+        if (use_alt_formatting)
+            vdigits_end = precision;
+        break;
+    case 'r':
+        /* convert to exponential format at 1e16.  We used to convert
+           at 1e17, but that gives odd-looking results for some values
+           when a 16-digit 'shortest' repr is padded with bogus zeros.
+           For example, repr(2e16+8) would give 20000000000000010.0;
+           the true value is 20000000000000008.0. */
+        if (decpt <= -4 || decpt > 16)
+            use_exp = 1;
+        break;
+    default:
+        PyErr_BadInternalCall();
+        goto exit;
+    }
+
+    /* if using an exponent, reset decimal point position to 1 and adjust
+       exponent accordingly.*/
+    if (use_exp) {
+        exp = decpt - 1;
+        decpt = 1;
+    }
+    /* ensure vdigits_start < decpt <= vdigits_end, or vdigits_start <
+       decpt < vdigits_end if add_dot_0_if_integer and no exponent */
+    vdigits_start = decpt <= 0 ? decpt-1 : 0;
+    if (!use_exp && add_dot_0_if_integer)
+        vdigits_end = vdigits_end > decpt ? vdigits_end : decpt + 1;
+    else
+        vdigits_end = vdigits_end > decpt ? vdigits_end : decpt;
+
+    /* double check inequalities */
+    assert(vdigits_start <= 0 &&
+           0 <= digits_len &&
+           digits_len <= vdigits_end);
+    /* decimal point should be in (vdigits_start, vdigits_end] */
+    assert(vdigits_start < decpt && decpt <= vdigits_end);
+
+    /* Compute an upper bound how much memory we need. This might be a few
+       chars too long, but no big deal. */
+    bufsize =
+        /* sign, decimal point and trailing 0 byte */
+        3 +
+
+        /* total digit count (including zero padding on both sides) */
+        (vdigits_end - vdigits_start) +
+
+        /* exponent "e+100", max 3 numerical digits */
+        (use_exp ? 5 : 0);
+
+    /* Now allocate the memory and initialize p to point to the start of
+       it. */
+    buf = (char *)PyMem_Malloc(bufsize);
+    if (buf == NULL) {
+        PyErr_NoMemory();
+        goto exit;
+    }
+    p = buf;
+
+    /* Add a negative sign if negative, and a plus sign if non-negative
+       and always_add_sign is true. */
+    if (sign == 1)
+        *p++ = '-';
+    else if (always_add_sign)
+        *p++ = '+';
+
+    /* note that exactly one of the three 'if' conditions is true,
+       so we include exactly one decimal point */
+    /* Zero padding on left of digit string */
+    if (decpt <= 0) {
+        memset(p, '0', decpt-vdigits_start);
+        p += decpt - vdigits_start;
+        *p++ = '.';
+        memset(p, '0', 0-decpt);
+        p += 0-decpt;
+    }
+    else {
+        memset(p, '0', 0-vdigits_start);
+        p += 0 - vdigits_start;
+    }
+
+    /* Digits, with included decimal point */
+    if (0 < decpt && decpt <= digits_len) {
+        strncpy(p, digits, decpt-0);
+        p += decpt-0;
+        *p++ = '.';
+        strncpy(p, digits+decpt, digits_len-decpt);
+        p += digits_len-decpt;
+    }
+    else {
+        strncpy(p, digits, digits_len);
+        p += digits_len;
+    }
+
+    /* And zeros on the right */
+    if (digits_len < decpt) {
+        memset(p, '0', decpt-digits_len);
+        p += decpt-digits_len;
+        *p++ = '.';
+        memset(p, '0', vdigits_end-decpt);
+        p += vdigits_end-decpt;
+    }
+    else {
+        memset(p, '0', vdigits_end-digits_len);
+        p += vdigits_end-digits_len;
+    }
+
+    /* Delete a trailing decimal pt unless using alternative formatting. */
+    if (p[-1] == '.' && !use_alt_formatting)
+        p--;
+
+    /* Now that we've done zero padding, add an exponent if needed. */
+    if (use_exp) {
+        *p++ = float_strings[OFS_E][0];
+        exp_len = sprintf(p, "%+.02d", exp);
+        p += exp_len;
+    }
   exit:
-	if (buf) {
-		*p = '\0';
-		/* It's too late if this fails, as we've already stepped on
-		   memory that isn't ours. But it's an okay debugging test. */
-		assert(p-buf < bufsize);
-	}
-	if (digits)
-		_Py_dg_freedtoa(digits);
-
-	return buf;
+    if (buf) {
+        *p = '\0';
+        /* It's too late if this fails, as we've already stepped on
+           memory that isn't ours. But it's an okay debugging test. */
+        assert(p-buf < bufsize);
+    }
+    if (digits)
+        _Py_dg_freedtoa(digits);
+
+    return buf;
 }
 
 
 PyAPI_FUNC(char *) PyOS_double_to_string(double val,
-					 char format_code,
-					 int precision,
-					 int flags,
-					 int *type)
+                                         char format_code,
+                                         int precision,
+                                         int flags,
+                                         int *type)
 {
-	char **float_strings = lc_float_strings;
-	int mode;
-
-	/* Validate format_code, and map upper and lower case. Compute the
-	   mode and make any adjustments as needed. */
-	switch (format_code) {
-	/* exponent */
-	case 'E':
-		float_strings = uc_float_strings;
-		format_code = 'e';
-		/* Fall through. */
-	case 'e':
-		mode = 2;
-		precision++;
-		break;
-
-	/* fixed */
-	case 'F':
-		float_strings = uc_float_strings;
-		format_code = 'f';
-		/* Fall through. */
-	case 'f':
-		mode = 3;
-		break;
-
-	/* general */
-	case 'G':
-		float_strings = uc_float_strings;
-		format_code = 'g';
-		/* Fall through. */
-	case 'g':
-		mode = 2;
-		/* precision 0 makes no sense for 'g' format; interpret as 1 */
-		if (precision == 0)
-			precision = 1;
-		break;
-
-	/* repr format */
-	case 'r':
-		mode = 0;
-		/* Supplied precision is unused, must be 0. */
-		if (precision != 0) {
-			PyErr_BadInternalCall();
-			return NULL;
-		}
-		break;
-
-	default:
-		PyErr_BadInternalCall();
-		return NULL;
-	}
-
-	return format_float_short(val, format_code, mode, precision,
-				  flags & Py_DTSF_SIGN,
-				  flags & Py_DTSF_ADD_DOT_0,
-				  flags & Py_DTSF_ALT,
-				  float_strings, type);
+    char **float_strings = lc_float_strings;
+    int mode;
+
+    /* Validate format_code, and map upper and lower case. Compute the
+       mode and make any adjustments as needed. */
+    switch (format_code) {
+    /* exponent */
+    case 'E':
+        float_strings = uc_float_strings;
+        format_code = 'e';
+        /* Fall through. */
+    case 'e':
+        mode = 2;
+        precision++;
+        break;
+
+    /* fixed */
+    case 'F':
+        float_strings = uc_float_strings;
+        format_code = 'f';
+        /* Fall through. */
+    case 'f':
+        mode = 3;
+        break;
+
+    /* general */
+    case 'G':
+        float_strings = uc_float_strings;
+        format_code = 'g';
+        /* Fall through. */
+    case 'g':
+        mode = 2;
+        /* precision 0 makes no sense for 'g' format; interpret as 1 */
+        if (precision == 0)
+            precision = 1;
+        break;
+
+    /* repr format */
+    case 'r':
+        mode = 0;
+        /* Supplied precision is unused, must be 0. */
+        if (precision != 0) {
+            PyErr_BadInternalCall();
+            return NULL;
+        }
+        break;
+
+    default:
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+
+    return format_float_short(val, format_code, mode, precision,
+                              flags & Py_DTSF_SIGN,
+                              flags & Py_DTSF_ADD_DOT_0,
+                              flags & Py_DTSF_ALT,
+                              float_strings, type);
 }
 #endif /* ifdef PY_NO_SHORT_FLOAT_REPR */
diff --git a/Python/pythonrun.c b/Python/pythonrun.c
index 71a53ea..f203618 100644
--- a/Python/pythonrun.c
+++ b/Python/pythonrun.c
@@ -40,9 +40,9 @@
 #ifndef Py_REF_DEBUG
 #define PRINT_TOTAL_REFS()
 #else /* Py_REF_DEBUG */
-#define PRINT_TOTAL_REFS() fprintf(stderr,				\
-				   "[%" PY_FORMAT_SIZE_T "d refs]\n",	\
-				   _Py_GetRefTotal())
+#define PRINT_TOTAL_REFS() fprintf(stderr,                              \
+                   "[%" PY_FORMAT_SIZE_T "d refs]\n",                   \
+                   _Py_GetRefTotal())
 #endif
 
 #ifdef __cplusplus
@@ -57,9 +57,9 @@ extern grammar _PyParser_Grammar; /* From graminit.c */
 static void initmain(void);
 static void initsite(void);
 static PyObject *run_mod(mod_ty, const char *, PyObject *, PyObject *,
-			  PyCompilerFlags *, PyArena *);
+                          PyCompilerFlags *, PyArena *);
 static PyObject *run_pyc_file(FILE *, const char *, PyObject *, PyObject *,
-			      PyCompilerFlags *);
+                              PyCompilerFlags *);
 static void err_input(perrdetail *);
 static void initsigs(void);
 static void wait_for_thread_shutdown(void);
@@ -95,7 +95,7 @@ since _warnings is builtin.  This API should not be used. */
 PyObject *
 PyModule_GetWarningsModule(void)
 {
-	return PyImport_ImportModule("warnings");
+    return PyImport_ImportModule("warnings");
 }
 
 static int initialized = 0;
@@ -105,7 +105,7 @@ static int initialized = 0;
 int
 Py_IsInitialized(void)
 {
-	return initialized;
+    return initialized;
 }
 
 /* Global initializations.  Can be undone by Py_Finalize().  Don't
@@ -123,251 +123,251 @@ Py_IsInitialized(void)
 static int
 add_flag(int flag, const char *envs)
 {
-	int env = atoi(envs);
-	if (flag < env)
-		flag = env;
-	if (flag < 1)
-		flag = 1;
-	return flag;
+    int env = atoi(envs);
+    if (flag < env)
+        flag = env;
+    if (flag < 1)
+        flag = 1;
+    return flag;
 }
 
 void
 Py_InitializeEx(int install_sigs)
 {
-	PyInterpreterState *interp;
-	PyThreadState *tstate;
-	PyObject *bimod, *sysmod;
-	char *p;
-	char *icodeset = NULL; /* On Windows, input codeset may theoretically
-			          differ from output codeset. */
-	char *codeset = NULL;
-	char *errors = NULL;
-	int free_codeset = 0;
-	int overridden = 0;
-	PyObject *sys_stream, *sys_isatty;
+    PyInterpreterState *interp;
+    PyThreadState *tstate;
+    PyObject *bimod, *sysmod;
+    char *p;
+    char *icodeset = NULL; /* On Windows, input codeset may theoretically
+                              differ from output codeset. */
+    char *codeset = NULL;
+    char *errors = NULL;
+    int free_codeset = 0;
+    int overridden = 0;
+    PyObject *sys_stream, *sys_isatty;
 #if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)
-	char *saved_locale, *loc_codeset;
+    char *saved_locale, *loc_codeset;
 #endif
 #ifdef MS_WINDOWS
-	char ibuf[128];
-	char buf[128];
+    char ibuf[128];
+    char buf[128];
 #endif
-	extern void _Py_ReadyTypes(void);
+    extern void _Py_ReadyTypes(void);
 
-	if (initialized)
-		return;
-	initialized = 1;
+    if (initialized)
+        return;
+    initialized = 1;
 
-	if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
-		Py_DebugFlag = add_flag(Py_DebugFlag, p);
-	if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
-		Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
-	if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
-		Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
-	if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0')
-		Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);
+    if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
+        Py_DebugFlag = add_flag(Py_DebugFlag, p);
+    if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
+        Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
+    if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
+        Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
+    if ((p = Py_GETENV("PYTHONDONTWRITEBYTECODE")) && *p != '\0')
+        Py_DontWriteBytecodeFlag = add_flag(Py_DontWriteBytecodeFlag, p);
 
-	interp = PyInterpreterState_New();
-	if (interp == NULL)
-		Py_FatalError("Py_Initialize: can't make first interpreter");
+    interp = PyInterpreterState_New();
+    if (interp == NULL)
+        Py_FatalError("Py_Initialize: can't make first interpreter");
 
-	tstate = PyThreadState_New(interp);
-	if (tstate == NULL)
-		Py_FatalError("Py_Initialize: can't make first thread");
-	(void) PyThreadState_Swap(tstate);
+    tstate = PyThreadState_New(interp);
+    if (tstate == NULL)
+        Py_FatalError("Py_Initialize: can't make first thread");
+    (void) PyThreadState_Swap(tstate);
 
-	_Py_ReadyTypes();
+    _Py_ReadyTypes();
 
-	if (!_PyFrame_Init())
-		Py_FatalError("Py_Initialize: can't init frames");
+    if (!_PyFrame_Init())
+        Py_FatalError("Py_Initialize: can't init frames");
 
-	if (!_PyInt_Init())
-		Py_FatalError("Py_Initialize: can't init ints");
+    if (!_PyInt_Init())
+        Py_FatalError("Py_Initialize: can't init ints");
 
-	if (!_PyLong_Init())
-		Py_FatalError("Py_Initialize: can't init longs");
+    if (!_PyLong_Init())
+        Py_FatalError("Py_Initialize: can't init longs");
 
-	if (!PyByteArray_Init())
-		Py_FatalError("Py_Initialize: can't init bytearray");
+    if (!PyByteArray_Init())
+        Py_FatalError("Py_Initialize: can't init bytearray");
 
-	_PyFloat_Init();
+    _PyFloat_Init();
 
-	interp->modules = PyDict_New();
-	if (interp->modules == NULL)
-		Py_FatalError("Py_Initialize: can't make modules dictionary");
-	interp->modules_reloading = PyDict_New();
-	if (interp->modules_reloading == NULL)
-		Py_FatalError("Py_Initialize: can't make modules_reloading dictionary");
+    interp->modules = PyDict_New();
+    if (interp->modules == NULL)
+        Py_FatalError("Py_Initialize: can't make modules dictionary");
+    interp->modules_reloading = PyDict_New();
+    if (interp->modules_reloading == NULL)
+        Py_FatalError("Py_Initialize: can't make modules_reloading dictionary");
 
 #ifdef Py_USING_UNICODE
-	/* Init Unicode implementation; relies on the codec registry */
-	_PyUnicode_Init();
+    /* Init Unicode implementation; relies on the codec registry */
+    _PyUnicode_Init();
 #endif
 
-	bimod = _PyBuiltin_Init();
-	if (bimod == NULL)
-		Py_FatalError("Py_Initialize: can't initialize __builtin__");
-	interp->builtins = PyModule_GetDict(bimod);
-	if (interp->builtins == NULL)
-		Py_FatalError("Py_Initialize: can't initialize builtins dict");
-	Py_INCREF(interp->builtins);
-
-	sysmod = _PySys_Init();
-	if (sysmod == NULL)
-		Py_FatalError("Py_Initialize: can't initialize sys");
-	interp->sysdict = PyModule_GetDict(sysmod);
-	if (interp->sysdict == NULL)
-		Py_FatalError("Py_Initialize: can't initialize sys dict");
-	Py_INCREF(interp->sysdict);
-	_PyImport_FixupExtension("sys", "sys");
-	PySys_SetPath(Py_GetPath());
-	PyDict_SetItemString(interp->sysdict, "modules",
-			     interp->modules);
-
-	_PyImport_Init();
-
-	/* initialize builtin exceptions */
-	_PyExc_Init();
-	_PyImport_FixupExtension("exceptions", "exceptions");
-
-	/* phase 2 of builtins */
-	_PyImport_FixupExtension("__builtin__", "__builtin__");
-
-	_PyImportHooks_Init();
-
-	if (install_sigs)
-		initsigs(); /* Signal handling stuff, including initintr() */
-
-	/* Initialize warnings. */
-	_PyWarnings_Init();
-	if (PySys_HasWarnOptions()) {
-		PyObject *warnings_module = PyImport_ImportModule("warnings");
-		if (!warnings_module)
-			PyErr_Clear();
-		Py_XDECREF(warnings_module);
-	}
-
-	initmain(); /* Module __main__ */
-
-	/* auto-thread-state API, if available */
+    bimod = _PyBuiltin_Init();
+    if (bimod == NULL)
+        Py_FatalError("Py_Initialize: can't initialize __builtin__");
+    interp->builtins = PyModule_GetDict(bimod);
+    if (interp->builtins == NULL)
+        Py_FatalError("Py_Initialize: can't initialize builtins dict");
+    Py_INCREF(interp->builtins);
+
+    sysmod = _PySys_Init();
+    if (sysmod == NULL)
+        Py_FatalError("Py_Initialize: can't initialize sys");
+    interp->sysdict = PyModule_GetDict(sysmod);
+    if (interp->sysdict == NULL)
+        Py_FatalError("Py_Initialize: can't initialize sys dict");
+    Py_INCREF(interp->sysdict);
+    _PyImport_FixupExtension("sys", "sys");
+    PySys_SetPath(Py_GetPath());
+    PyDict_SetItemString(interp->sysdict, "modules",
+                         interp->modules);
+
+    _PyImport_Init();
+
+    /* initialize builtin exceptions */
+    _PyExc_Init();
+    _PyImport_FixupExtension("exceptions", "exceptions");
+
+    /* phase 2 of builtins */
+    _PyImport_FixupExtension("__builtin__", "__builtin__");
+
+    _PyImportHooks_Init();
+
+    if (install_sigs)
+        initsigs(); /* Signal handling stuff, including initintr() */
+
+    /* Initialize warnings. */
+    _PyWarnings_Init();
+    if (PySys_HasWarnOptions()) {
+        PyObject *warnings_module = PyImport_ImportModule("warnings");
+        if (!warnings_module)
+            PyErr_Clear();
+        Py_XDECREF(warnings_module);
+    }
+
+    initmain(); /* Module __main__ */
+
+    /* auto-thread-state API, if available */
 #ifdef WITH_THREAD
-	_PyGILState_Init(interp, tstate);
+    _PyGILState_Init(interp, tstate);
 #endif /* WITH_THREAD */
 
-	if (!Py_NoSiteFlag)
-		initsite(); /* Module site */
+    if (!Py_NoSiteFlag)
+        initsite(); /* Module site */
 
-	if ((p = Py_GETENV("PYTHONIOENCODING")) && *p != '\0') {
-		p = icodeset = codeset = strdup(p);
-		free_codeset = 1;
-		errors = strchr(p, ':');
-		if (errors) {
-			*errors = '\0';
-			errors++;
-		}
-		overridden = 1;
-	}
+    if ((p = Py_GETENV("PYTHONIOENCODING")) && *p != '\0') {
+        p = icodeset = codeset = strdup(p);
+        free_codeset = 1;
+        errors = strchr(p, ':');
+        if (errors) {
+            *errors = '\0';
+            errors++;
+        }
+        overridden = 1;
+    }
 
 #if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)
-	/* On Unix, set the file system encoding according to the
-	   user's preference, if the CODESET names a well-known
-	   Python codec, and Py_FileSystemDefaultEncoding isn't
-	   initialized by other means. Also set the encoding of
-	   stdin and stdout if these are terminals, unless overridden.  */
-
-	if (!overridden || !Py_FileSystemDefaultEncoding) {
-		saved_locale = strdup(setlocale(LC_CTYPE, NULL));
-		setlocale(LC_CTYPE, "");
-		loc_codeset = nl_langinfo(CODESET);
-		if (loc_codeset && *loc_codeset) {
-			PyObject *enc = PyCodec_Encoder(loc_codeset);
-			if (enc) {
-				loc_codeset = strdup(loc_codeset);
-				Py_DECREF(enc);
-			} else {
-				if (PyErr_ExceptionMatches(PyExc_LookupError)) {
-					PyErr_Clear();
-					loc_codeset = NULL;
-				} else {
-					PyErr_Print();
-					exit(1);
-				}
-			}
-		} else
-			loc_codeset = NULL;
-		setlocale(LC_CTYPE, saved_locale);
-		free(saved_locale);
-
-		if (!overridden) {
-			codeset = icodeset = loc_codeset;
-			free_codeset = 1;
-		}
-
-		/* Initialize Py_FileSystemDefaultEncoding from
-		   locale even if PYTHONIOENCODING is set. */
-		if (!Py_FileSystemDefaultEncoding) {
-			Py_FileSystemDefaultEncoding = loc_codeset;
-			if (!overridden)
-				free_codeset = 0;
-		}
-	}
+    /* On Unix, set the file system encoding according to the
+       user's preference, if the CODESET names a well-known
+       Python codec, and Py_FileSystemDefaultEncoding isn't
+       initialized by other means. Also set the encoding of
+       stdin and stdout if these are terminals, unless overridden.  */
+
+    if (!overridden || !Py_FileSystemDefaultEncoding) {
+        saved_locale = strdup(setlocale(LC_CTYPE, NULL));
+        setlocale(LC_CTYPE, "");
+        loc_codeset = nl_langinfo(CODESET);
+        if (loc_codeset && *loc_codeset) {
+            PyObject *enc = PyCodec_Encoder(loc_codeset);
+            if (enc) {
+                loc_codeset = strdup(loc_codeset);
+                Py_DECREF(enc);
+            } else {
+                if (PyErr_ExceptionMatches(PyExc_LookupError)) {
+                    PyErr_Clear();
+                    loc_codeset = NULL;
+                } else {
+                    PyErr_Print();
+                    exit(1);
+                }
+            }
+        } else
+            loc_codeset = NULL;
+        setlocale(LC_CTYPE, saved_locale);
+        free(saved_locale);
+
+        if (!overridden) {
+            codeset = icodeset = loc_codeset;
+            free_codeset = 1;
+        }
+
+        /* Initialize Py_FileSystemDefaultEncoding from
+           locale even if PYTHONIOENCODING is set. */
+        if (!Py_FileSystemDefaultEncoding) {
+            Py_FileSystemDefaultEncoding = loc_codeset;
+            if (!overridden)
+                free_codeset = 0;
+        }
+    }
 #endif
 
 #ifdef MS_WINDOWS
-	if (!overridden) {
-		icodeset = ibuf;
-		codeset = buf;
-		sprintf(ibuf, "cp%d", GetConsoleCP());
-		sprintf(buf, "cp%d", GetConsoleOutputCP());
-	}
+    if (!overridden) {
+        icodeset = ibuf;
+        codeset = buf;
+        sprintf(ibuf, "cp%d", GetConsoleCP());
+        sprintf(buf, "cp%d", GetConsoleOutputCP());
+    }
 #endif
 
-	if (codeset) {
-		sys_stream = PySys_GetObject("stdin");
-		sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
-		if (!sys_isatty)
-			PyErr_Clear();
-		if ((overridden ||
-		     (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
-		   PyFile_Check(sys_stream)) {
-			if (!PyFile_SetEncodingAndErrors(sys_stream, icodeset, errors))
-				Py_FatalError("Cannot set codeset of stdin");
-		}
-		Py_XDECREF(sys_isatty);
-
-		sys_stream = PySys_GetObject("stdout");
-		sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
-		if (!sys_isatty)
-			PyErr_Clear();
-		if ((overridden ||
-		     (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
-		   PyFile_Check(sys_stream)) {
-			if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))
-				Py_FatalError("Cannot set codeset of stdout");
-		}
-		Py_XDECREF(sys_isatty);
-
-		sys_stream = PySys_GetObject("stderr");
-		sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
-		if (!sys_isatty)
-			PyErr_Clear();
-		if((overridden ||
-		    (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
-		   PyFile_Check(sys_stream)) {
-			if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))
-				Py_FatalError("Cannot set codeset of stderr");
-		}
-		Py_XDECREF(sys_isatty);
-
-		if (free_codeset)
-			free(codeset);
-	}
+    if (codeset) {
+        sys_stream = PySys_GetObject("stdin");
+        sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
+        if (!sys_isatty)
+            PyErr_Clear();
+        if ((overridden ||
+             (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
+           PyFile_Check(sys_stream)) {
+            if (!PyFile_SetEncodingAndErrors(sys_stream, icodeset, errors))
+                Py_FatalError("Cannot set codeset of stdin");
+        }
+        Py_XDECREF(sys_isatty);
+
+        sys_stream = PySys_GetObject("stdout");
+        sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
+        if (!sys_isatty)
+            PyErr_Clear();
+        if ((overridden ||
+             (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
+           PyFile_Check(sys_stream)) {
+            if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))
+                Py_FatalError("Cannot set codeset of stdout");
+        }
+        Py_XDECREF(sys_isatty);
+
+        sys_stream = PySys_GetObject("stderr");
+        sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
+        if (!sys_isatty)
+            PyErr_Clear();
+        if((overridden ||
+            (sys_isatty && PyObject_IsTrue(sys_isatty))) &&
+           PyFile_Check(sys_stream)) {
+            if (!PyFile_SetEncodingAndErrors(sys_stream, codeset, errors))
+                Py_FatalError("Cannot set codeset of stderr");
+        }
+        Py_XDECREF(sys_isatty);
+
+        if (free_codeset)
+            free(codeset);
+    }
 }
 
 void
 Py_Initialize(void)
 {
-	Py_InitializeEx(1);
+    Py_InitializeEx(1);
 }
 
 
@@ -392,159 +392,159 @@ extern void dump_counts(FILE*);
 void
 Py_Finalize(void)
 {
-	PyInterpreterState *interp;
-	PyThreadState *tstate;
-
-	if (!initialized)
-		return;
-
-	wait_for_thread_shutdown();
-
-	/* The interpreter is still entirely intact at this point, and the
-	 * exit funcs may be relying on that.  In particular, if some thread
-	 * or exit func is still waiting to do an import, the import machinery
-	 * expects Py_IsInitialized() to return true.  So don't say the
-	 * interpreter is uninitialized until after the exit funcs have run.
-	 * Note that Threading.py uses an exit func to do a join on all the
-	 * threads created thru it, so this also protects pending imports in
-	 * the threads created via Threading.
-	 */
-	call_sys_exitfunc();
-	initialized = 0;
-
-	/* Get current thread state and interpreter pointer */
-	tstate = PyThreadState_GET();
-	interp = tstate->interp;
-
-	/* Disable signal handling */
-	PyOS_FiniInterrupts();
-
-	/* Clear type lookup cache */
-	PyType_ClearCache();
-
-	/* Collect garbage.  This may call finalizers; it's nice to call these
-	 * before all modules are destroyed.
-	 * XXX If a __del__ or weakref callback is triggered here, and tries to
-	 * XXX import a module, bad things can happen, because Python no
-	 * XXX longer believes it's initialized.
-	 * XXX     Fatal Python error: Interpreter not initialized (version mismatch?)
-	 * XXX is easy to provoke that way.  I've also seen, e.g.,
-	 * XXX     Exception exceptions.ImportError: 'No module named sha'
-	 * XXX         in <function callback at 0x008F5718> ignored
-	 * XXX but I'm unclear on exactly how that one happens.  In any case,
-	 * XXX I haven't seen a real-life report of either of these.
-	 */
-	PyGC_Collect();
+    PyInterpreterState *interp;
+    PyThreadState *tstate;
+
+    if (!initialized)
+        return;
+
+    wait_for_thread_shutdown();
+
+    /* The interpreter is still entirely intact at this point, and the
+     * exit funcs may be relying on that.  In particular, if some thread
+     * or exit func is still waiting to do an import, the import machinery
+     * expects Py_IsInitialized() to return true.  So don't say the
+     * interpreter is uninitialized until after the exit funcs have run.
+     * Note that Threading.py uses an exit func to do a join on all the
+     * threads created thru it, so this also protects pending imports in
+     * the threads created via Threading.
+     */
+    call_sys_exitfunc();
+    initialized = 0;
+
+    /* Get current thread state and interpreter pointer */
+    tstate = PyThreadState_GET();
+    interp = tstate->interp;
+
+    /* Disable signal handling */
+    PyOS_FiniInterrupts();
+
+    /* Clear type lookup cache */
+    PyType_ClearCache();
+
+    /* Collect garbage.  This may call finalizers; it's nice to call these
+     * before all modules are destroyed.
+     * XXX If a __del__ or weakref callback is triggered here, and tries to
+     * XXX import a module, bad things can happen, because Python no
+     * XXX longer believes it's initialized.
+     * XXX     Fatal Python error: Interpreter not initialized (version mismatch?)
+     * XXX is easy to provoke that way.  I've also seen, e.g.,
+     * XXX     Exception exceptions.ImportError: 'No module named sha'
+     * XXX         in <function callback at 0x008F5718> ignored
+     * XXX but I'm unclear on exactly how that one happens.  In any case,
+     * XXX I haven't seen a real-life report of either of these.
+     */
+    PyGC_Collect();
 #ifdef COUNT_ALLOCS
-	/* With COUNT_ALLOCS, it helps to run GC multiple times:
-	   each collection might release some types from the type
-	   list, so they become garbage. */
-	while (PyGC_Collect() > 0)
-		/* nothing */;
+    /* With COUNT_ALLOCS, it helps to run GC multiple times:
+       each collection might release some types from the type
+       list, so they become garbage. */
+    while (PyGC_Collect() > 0)
+        /* nothing */;
 #endif
 
-	/* Destroy all modules */
-	PyImport_Cleanup();
-
-	/* Collect final garbage.  This disposes of cycles created by
-	 * new-style class definitions, for example.
-	 * XXX This is disabled because it caused too many problems.  If
-	 * XXX a __del__ or weakref callback triggers here, Python code has
-	 * XXX a hard time running, because even the sys module has been
-	 * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc).
-	 * XXX One symptom is a sequence of information-free messages
-	 * XXX coming from threads (if a __del__ or callback is invoked,
-	 * XXX other threads can execute too, and any exception they encounter
-	 * XXX triggers a comedy of errors as subsystem after subsystem
-	 * XXX fails to find what it *expects* to find in sys to help report
-	 * XXX the exception and consequent unexpected failures).  I've also
-	 * XXX seen segfaults then, after adding print statements to the
-	 * XXX Python code getting called.
-	 */
+    /* Destroy all modules */
+    PyImport_Cleanup();
+
+    /* Collect final garbage.  This disposes of cycles created by
+     * new-style class definitions, for example.
+     * XXX This is disabled because it caused too many problems.  If
+     * XXX a __del__ or weakref callback triggers here, Python code has
+     * XXX a hard time running, because even the sys module has been
+     * XXX cleared out (sys.stdout is gone, sys.excepthook is gone, etc).
+     * XXX One symptom is a sequence of information-free messages
+     * XXX coming from threads (if a __del__ or callback is invoked,
+     * XXX other threads can execute too, and any exception they encounter
+     * XXX triggers a comedy of errors as subsystem after subsystem
+     * XXX fails to find what it *expects* to find in sys to help report
+     * XXX the exception and consequent unexpected failures).  I've also
+     * XXX seen segfaults then, after adding print statements to the
+     * XXX Python code getting called.
+     */
 #if 0
-	PyGC_Collect();
+    PyGC_Collect();
 #endif
 
-	/* Destroy the database used by _PyImport_{Fixup,Find}Extension */
-	_PyImport_Fini();
+    /* Destroy the database used by _PyImport_{Fixup,Find}Extension */
+    _PyImport_Fini();
 
-	/* Debugging stuff */
+    /* Debugging stuff */
 #ifdef COUNT_ALLOCS
-	dump_counts(stdout);
+    dump_counts(stdout);
 #endif
 
-	PRINT_TOTAL_REFS();
+    PRINT_TOTAL_REFS();
 
 #ifdef Py_TRACE_REFS
-	/* Display all objects still alive -- this can invoke arbitrary
-	 * __repr__ overrides, so requires a mostly-intact interpreter.
-	 * Alas, a lot of stuff may still be alive now that will be cleaned
-	 * up later.
-	 */
-	if (Py_GETENV("PYTHONDUMPREFS"))
-		_Py_PrintReferences(stderr);
+    /* Display all objects still alive -- this can invoke arbitrary
+     * __repr__ overrides, so requires a mostly-intact interpreter.
+     * Alas, a lot of stuff may still be alive now that will be cleaned
+     * up later.
+     */
+    if (Py_GETENV("PYTHONDUMPREFS"))
+        _Py_PrintReferences(stderr);
 #endif /* Py_TRACE_REFS */
 
-	/* Clear interpreter state */
-	PyInterpreterState_Clear(interp);
+    /* Clear interpreter state */
+    PyInterpreterState_Clear(interp);
 
-	/* Now we decref the exception classes.  After this point nothing
-	   can raise an exception.  That's okay, because each Fini() method
-	   below has been checked to make sure no exceptions are ever
-	   raised.
-	*/
+    /* Now we decref the exception classes.  After this point nothing
+       can raise an exception.  That's okay, because each Fini() method
+       below has been checked to make sure no exceptions are ever
+       raised.
+    */
 
-	_PyExc_Fini();
+    _PyExc_Fini();
 
-	/* Cleanup auto-thread-state */
+    /* Cleanup auto-thread-state */
 #ifdef WITH_THREAD
-	_PyGILState_Fini();
+    _PyGILState_Fini();
 #endif /* WITH_THREAD */
 
-	/* Delete current thread */
-	PyThreadState_Swap(NULL);
-	PyInterpreterState_Delete(interp);
-
-	/* Sundry finalizers */
-	PyMethod_Fini();
-	PyFrame_Fini();
-	PyCFunction_Fini();
-	PyTuple_Fini();
-	PyList_Fini();
-	PySet_Fini();
-	PyString_Fini();
-	PyByteArray_Fini();
-	PyInt_Fini();
-	PyFloat_Fini();
-	PyDict_Fini();
+    /* Delete current thread */
+    PyThreadState_Swap(NULL);
+    PyInterpreterState_Delete(interp);
+
+    /* Sundry finalizers */
+    PyMethod_Fini();
+    PyFrame_Fini();
+    PyCFunction_Fini();
+    PyTuple_Fini();
+    PyList_Fini();
+    PySet_Fini();
+    PyString_Fini();
+    PyByteArray_Fini();
+    PyInt_Fini();
+    PyFloat_Fini();
+    PyDict_Fini();
 
 #ifdef Py_USING_UNICODE
-	/* Cleanup Unicode implementation */
-	_PyUnicode_Fini();
+    /* Cleanup Unicode implementation */
+    _PyUnicode_Fini();
 #endif
 
-	/* XXX Still allocated:
-	   - various static ad-hoc pointers to interned strings
-	   - int and float free list blocks
-	   - whatever various modules and libraries allocate
-	*/
+    /* XXX Still allocated:
+       - various static ad-hoc pointers to interned strings
+       - int and float free list blocks
+       - whatever various modules and libraries allocate
+    */
 
-	PyGrammar_RemoveAccelerators(&_PyParser_Grammar);
+    PyGrammar_RemoveAccelerators(&_PyParser_Grammar);
 
 #ifdef Py_TRACE_REFS
-	/* Display addresses (& refcnts) of all objects still alive.
-	 * An address can be used to find the repr of the object, printed
-	 * above by _Py_PrintReferences.
-	 */
-	if (Py_GETENV("PYTHONDUMPREFS"))
-		_Py_PrintReferenceAddresses(stderr);
+    /* Display addresses (& refcnts) of all objects still alive.
+     * An address can be used to find the repr of the object, printed
+     * above by _Py_PrintReferences.
+     */
+    if (Py_GETENV("PYTHONDUMPREFS"))
+        _Py_PrintReferenceAddresses(stderr);
 #endif /* Py_TRACE_REFS */
 #ifdef PYMALLOC_DEBUG
-	if (Py_GETENV("PYTHONMALLOCSTATS"))
-		_PyObject_DebugMallocStats();
+    if (Py_GETENV("PYTHONMALLOCSTATS"))
+        _PyObject_DebugMallocStats();
 #endif
 
-	call_ll_exitfuncs();
+    call_ll_exitfuncs();
 }
 
 /* Create and initialize a new interpreter and thread, and return the
@@ -563,65 +563,65 @@ Py_Finalize(void)
 PyThreadState *
 Py_NewInterpreter(void)
 {
-	PyInterpreterState *interp;
-	PyThreadState *tstate, *save_tstate;
-	PyObject *bimod, *sysmod;
-
-	if (!initialized)
-		Py_FatalError("Py_NewInterpreter: call Py_Initialize first");
-
-	interp = PyInterpreterState_New();
-	if (interp == NULL)
-		return NULL;
-
-	tstate = PyThreadState_New(interp);
-	if (tstate == NULL) {
-		PyInterpreterState_Delete(interp);
-		return NULL;
-	}
-
-	save_tstate = PyThreadState_Swap(tstate);
-
-	/* XXX The following is lax in error checking */
-
-	interp->modules = PyDict_New();
-	interp->modules_reloading = PyDict_New();
-
-	bimod = _PyImport_FindExtension("__builtin__", "__builtin__");
-	if (bimod != NULL) {
-		interp->builtins = PyModule_GetDict(bimod);
-		if (interp->builtins == NULL)
-			goto handle_error;
-		Py_INCREF(interp->builtins);
-	}
-	sysmod = _PyImport_FindExtension("sys", "sys");
-	if (bimod != NULL && sysmod != NULL) {
-		interp->sysdict = PyModule_GetDict(sysmod);
-		if (interp->sysdict == NULL)
-			goto handle_error;
-		Py_INCREF(interp->sysdict);
-		PySys_SetPath(Py_GetPath());
-		PyDict_SetItemString(interp->sysdict, "modules",
-				     interp->modules);
-		_PyImportHooks_Init();
-		initmain();
-		if (!Py_NoSiteFlag)
-			initsite();
-	}
-
-	if (!PyErr_Occurred())
-		return tstate;
+    PyInterpreterState *interp;
+    PyThreadState *tstate, *save_tstate;
+    PyObject *bimod, *sysmod;
+
+    if (!initialized)
+        Py_FatalError("Py_NewInterpreter: call Py_Initialize first");
+
+    interp = PyInterpreterState_New();
+    if (interp == NULL)
+        return NULL;
+
+    tstate = PyThreadState_New(interp);
+    if (tstate == NULL) {
+        PyInterpreterState_Delete(interp);
+        return NULL;
+    }
+
+    save_tstate = PyThreadState_Swap(tstate);
+
+    /* XXX The following is lax in error checking */
+
+    interp->modules = PyDict_New();
+    interp->modules_reloading = PyDict_New();
+
+    bimod = _PyImport_FindExtension("__builtin__", "__builtin__");
+    if (bimod != NULL) {
+        interp->builtins = PyModule_GetDict(bimod);
+        if (interp->builtins == NULL)
+            goto handle_error;
+        Py_INCREF(interp->builtins);
+    }
+    sysmod = _PyImport_FindExtension("sys", "sys");
+    if (bimod != NULL && sysmod != NULL) {
+        interp->sysdict = PyModule_GetDict(sysmod);
+        if (interp->sysdict == NULL)
+            goto handle_error;
+        Py_INCREF(interp->sysdict);
+        PySys_SetPath(Py_GetPath());
+        PyDict_SetItemString(interp->sysdict, "modules",
+                             interp->modules);
+        _PyImportHooks_Init();
+        initmain();
+        if (!Py_NoSiteFlag)
+            initsite();
+    }
+
+    if (!PyErr_Occurred())
+        return tstate;
 
 handle_error:
-	/* Oops, it didn't work.  Undo it all. */
+    /* Oops, it didn't work.  Undo it all. */
 
-	PyErr_Print();
-	PyThreadState_Clear(tstate);
-	PyThreadState_Swap(save_tstate);
-	PyThreadState_Delete(tstate);
-	PyInterpreterState_Delete(interp);
+    PyErr_Print();
+    PyThreadState_Clear(tstate);
+    PyThreadState_Swap(save_tstate);
+    PyThreadState_Delete(tstate);
+    PyInterpreterState_Delete(interp);
 
-	return NULL;
+    return NULL;
 }
 
 /* Delete an interpreter and its last thread.  This requires that the
@@ -639,19 +639,19 @@ handle_error:
 void
 Py_EndInterpreter(PyThreadState *tstate)
 {
-	PyInterpreterState *interp = tstate->interp;
+    PyInterpreterState *interp = tstate->interp;
 
-	if (tstate != PyThreadState_GET())
-		Py_FatalError("Py_EndInterpreter: thread is not current");
-	if (tstate->frame != NULL)
-		Py_FatalError("Py_EndInterpreter: thread still has a frame");
-	if (tstate != interp->tstate_head || tstate->next != NULL)
-		Py_FatalError("Py_EndInterpreter: not the last thread");
+    if (tstate != PyThreadState_GET())
+        Py_FatalError("Py_EndInterpreter: thread is not current");
+    if (tstate->frame != NULL)
+        Py_FatalError("Py_EndInterpreter: thread still has a frame");
+    if (tstate != interp->tstate_head || tstate->next != NULL)
+        Py_FatalError("Py_EndInterpreter: not the last thread");
 
-	PyImport_Cleanup();
-	PyInterpreterState_Clear(interp);
-	PyThreadState_Swap(NULL);
-	PyInterpreterState_Delete(interp);
+    PyImport_Cleanup();
+    PyInterpreterState_Clear(interp);
+    PyThreadState_Swap(NULL);
+    PyInterpreterState_Delete(interp);
 }
 
 static char *progname = "python";
@@ -659,14 +659,14 @@ static char *progname = "python";
 void
 Py_SetProgramName(char *pn)
 {
-	if (pn && *pn)
-		progname = pn;
+    if (pn && *pn)
+        progname = pn;
 }
 
 char *
 Py_GetProgramName(void)
 {
-	return progname;
+    return progname;
 }
 
 static char *default_home = NULL;
@@ -674,16 +674,16 @@ static char *default_home = NULL;
 void
 Py_SetPythonHome(char *home)
 {
-	default_home = home;
+    default_home = home;
 }
 
 char *
 Py_GetPythonHome(void)
 {
-	char *home = default_home;
-	if (home == NULL && !Py_IgnoreEnvironmentFlag)
-		home = Py_GETENV("PYTHONHOME");
-	return home;
+    char *home = default_home;
+    if (home == NULL && !Py_IgnoreEnvironmentFlag)
+        home = Py_GETENV("PYTHONHOME");
+    return home;
 }
 
 /* Create __main__ module */
@@ -691,18 +691,18 @@ Py_GetPythonHome(void)
 static void
 initmain(void)
 {
-	PyObject *m, *d;
-	m = PyImport_AddModule("__main__");
-	if (m == NULL)
-		Py_FatalError("can't create __main__ module");
-	d = PyModule_GetDict(m);
-	if (PyDict_GetItemString(d, "__builtins__") == NULL) {
-		PyObject *bimod = PyImport_ImportModule("__builtin__");
-		if (bimod == NULL ||
-		    PyDict_SetItemString(d, "__builtins__", bimod) != 0)
-			Py_FatalError("can't add __builtins__ to __main__");
-		Py_XDECREF(bimod);
-	}
+    PyObject *m, *d;
+    m = PyImport_AddModule("__main__");
+    if (m == NULL)
+        Py_FatalError("can't create __main__ module");
+    d = PyModule_GetDict(m);
+    if (PyDict_GetItemString(d, "__builtins__") == NULL) {
+        PyObject *bimod = PyImport_ImportModule("__builtin__");
+        if (bimod == NULL ||
+            PyDict_SetItemString(d, "__builtins__", bimod) != 0)
+            Py_FatalError("can't add __builtins__ to __main__");
+        Py_XDECREF(bimod);
+    }
 }
 
 /* Import the site module (not into __main__ though) */
@@ -710,148 +710,148 @@ initmain(void)
 static void
 initsite(void)
 {
-	PyObject *m;
-	m = PyImport_ImportModule("site");
-	if (m == NULL) {
-		PyErr_Print();
-		Py_Finalize();
-		exit(1);
-	}
-	else {
-		Py_DECREF(m);
-	}
+    PyObject *m;
+    m = PyImport_ImportModule("site");
+    if (m == NULL) {
+        PyErr_Print();
+        Py_Finalize();
+        exit(1);
+    }
+    else {
+        Py_DECREF(m);
+    }
 }
 
 /* Parse input from a file and execute it */
 
 int
 PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit,
-		     PyCompilerFlags *flags)
+                     PyCompilerFlags *flags)
 {
-	if (filename == NULL)
-		filename = "???";
-	if (Py_FdIsInteractive(fp, filename)) {
-		int err = PyRun_InteractiveLoopFlags(fp, filename, flags);
-		if (closeit)
-			fclose(fp);
-		return err;
-	}
-	else
-		return PyRun_SimpleFileExFlags(fp, filename, closeit, flags);
+    if (filename == NULL)
+        filename = "???";
+    if (Py_FdIsInteractive(fp, filename)) {
+        int err = PyRun_InteractiveLoopFlags(fp, filename, flags);
+        if (closeit)
+            fclose(fp);
+        return err;
+    }
+    else
+        return PyRun_SimpleFileExFlags(fp, filename, closeit, flags);
 }
 
 int
 PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
 {
-	PyObject *v;
-	int ret;
-	PyCompilerFlags local_flags;
-
-	if (flags == NULL) {
-		flags = &local_flags;
-		local_flags.cf_flags = 0;
-	}
-	v = PySys_GetObject("ps1");
-	if (v == NULL) {
-		PySys_SetObject("ps1", v = PyString_FromString(">>> "));
-		Py_XDECREF(v);
-	}
-	v = PySys_GetObject("ps2");
-	if (v == NULL) {
-		PySys_SetObject("ps2", v = PyString_FromString("... "));
-		Py_XDECREF(v);
-	}
-	for (;;) {
-		ret = PyRun_InteractiveOneFlags(fp, filename, flags);
-		PRINT_TOTAL_REFS();
-		if (ret == E_EOF)
-			return 0;
-		/*
-		if (ret == E_NOMEM)
-			return -1;
-		*/
-	}
+    PyObject *v;
+    int ret;
+    PyCompilerFlags local_flags;
+
+    if (flags == NULL) {
+        flags = &local_flags;
+        local_flags.cf_flags = 0;
+    }
+    v = PySys_GetObject("ps1");
+    if (v == NULL) {
+        PySys_SetObject("ps1", v = PyString_FromString(">>> "));
+        Py_XDECREF(v);
+    }
+    v = PySys_GetObject("ps2");
+    if (v == NULL) {
+        PySys_SetObject("ps2", v = PyString_FromString("... "));
+        Py_XDECREF(v);
+    }
+    for (;;) {
+        ret = PyRun_InteractiveOneFlags(fp, filename, flags);
+        PRINT_TOTAL_REFS();
+        if (ret == E_EOF)
+            return 0;
+        /*
+        if (ret == E_NOMEM)
+            return -1;
+        */
+    }
 }
 
 #if 0
 /* compute parser flags based on compiler flags */
 #define PARSER_FLAGS(flags) \
-	((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
-		      PyPARSE_DONT_IMPLY_DEDENT : 0)) : 0)
+    ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
+                  PyPARSE_DONT_IMPLY_DEDENT : 0)) : 0)
 #endif
 #if 1
 /* Keep an example of flags with future keyword support. */
 #define PARSER_FLAGS(flags) \
-	((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
-		      PyPARSE_DONT_IMPLY_DEDENT : 0) \
-		    | (((flags)->cf_flags & CO_FUTURE_PRINT_FUNCTION) ? \
-		       PyPARSE_PRINT_IS_FUNCTION : 0) \
-		    | (((flags)->cf_flags & CO_FUTURE_UNICODE_LITERALS) ? \
-		       PyPARSE_UNICODE_LITERALS : 0) \
-		    ) : 0)
+    ((flags) ? ((((flags)->cf_flags & PyCF_DONT_IMPLY_DEDENT) ? \
+                  PyPARSE_DONT_IMPLY_DEDENT : 0) \
+                | (((flags)->cf_flags & CO_FUTURE_PRINT_FUNCTION) ? \
+                   PyPARSE_PRINT_IS_FUNCTION : 0) \
+                | (((flags)->cf_flags & CO_FUTURE_UNICODE_LITERALS) ? \
+                   PyPARSE_UNICODE_LITERALS : 0) \
+                ) : 0)
 #endif
 
 int
 PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
 {
-	PyObject *m, *d, *v, *w;
-	mod_ty mod;
-	PyArena *arena;
-	char *ps1 = "", *ps2 = "";
-	int errcode = 0;
-
-	v = PySys_GetObject("ps1");
-	if (v != NULL) {
-		v = PyObject_Str(v);
-		if (v == NULL)
-			PyErr_Clear();
-		else if (PyString_Check(v))
-			ps1 = PyString_AsString(v);
-	}
-	w = PySys_GetObject("ps2");
-	if (w != NULL) {
-		w = PyObject_Str(w);
-		if (w == NULL)
-			PyErr_Clear();
-		else if (PyString_Check(w))
-			ps2 = PyString_AsString(w);
-	}
-	arena = PyArena_New();
-	if (arena == NULL) {
-		Py_XDECREF(v);
-		Py_XDECREF(w);
-		return -1;
-	}
-	mod = PyParser_ASTFromFile(fp, filename,
-				   Py_single_input, ps1, ps2,
-				   flags, &errcode, arena);
-	Py_XDECREF(v);
-	Py_XDECREF(w);
-	if (mod == NULL) {
-		PyArena_Free(arena);
-		if (errcode == E_EOF) {
-			PyErr_Clear();
-			return E_EOF;
-		}
-		PyErr_Print();
-		return -1;
-	}
-	m = PyImport_AddModule("__main__");
-	if (m == NULL) {
-		PyArena_Free(arena);
-		return -1;
-	}
-	d = PyModule_GetDict(m);
-	v = run_mod(mod, filename, d, d, flags, arena);
-	PyArena_Free(arena);
-	if (v == NULL) {
-		PyErr_Print();
-		return -1;
-	}
-	Py_DECREF(v);
-	if (Py_FlushLine())
-		PyErr_Clear();
-	return 0;
+    PyObject *m, *d, *v, *w;
+    mod_ty mod;
+    PyArena *arena;
+    char *ps1 = "", *ps2 = "";
+    int errcode = 0;
+
+    v = PySys_GetObject("ps1");
+    if (v != NULL) {
+        v = PyObject_Str(v);
+        if (v == NULL)
+            PyErr_Clear();
+        else if (PyString_Check(v))
+            ps1 = PyString_AsString(v);
+    }
+    w = PySys_GetObject("ps2");
+    if (w != NULL) {
+        w = PyObject_Str(w);
+        if (w == NULL)
+            PyErr_Clear();
+        else if (PyString_Check(w))
+            ps2 = PyString_AsString(w);
+    }
+    arena = PyArena_New();
+    if (arena == NULL) {
+        Py_XDECREF(v);
+        Py_XDECREF(w);
+        return -1;
+    }
+    mod = PyParser_ASTFromFile(fp, filename,
+                               Py_single_input, ps1, ps2,
+                               flags, &errcode, arena);
+    Py_XDECREF(v);
+    Py_XDECREF(w);
+    if (mod == NULL) {
+        PyArena_Free(arena);
+        if (errcode == E_EOF) {
+            PyErr_Clear();
+            return E_EOF;
+        }
+        PyErr_Print();
+        return -1;
+    }
+    m = PyImport_AddModule("__main__");
+    if (m == NULL) {
+        PyArena_Free(arena);
+        return -1;
+    }
+    d = PyModule_GetDict(m);
+    v = run_mod(mod, filename, d, d, flags, arena);
+    PyArena_Free(arena);
+    if (v == NULL) {
+        PyErr_Print();
+        return -1;
+    }
+    Py_DECREF(v);
+    if (Py_FlushLine())
+        PyErr_Clear();
+    return 0;
 }
 
 /* Check whether a file maybe a pyc file: Look at the extension,
@@ -860,624 +860,624 @@ PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags
 static int
 maybe_pyc_file(FILE *fp, const char* filename, const char* ext, int closeit)
 {
-	if (strcmp(ext, ".pyc") == 0 || strcmp(ext, ".pyo") == 0)
-		return 1;
-
-	/* Only look into the file if we are allowed to close it, since
-	   it then should also be seekable. */
-	if (closeit) {
-		/* Read only two bytes of the magic. If the file was opened in
-		   text mode, the bytes 3 and 4 of the magic (\r\n) might not
-		   be read as they are on disk. */
-		unsigned int halfmagic = PyImport_GetMagicNumber() & 0xFFFF;
-		unsigned char buf[2];
-		/* Mess:  In case of -x, the stream is NOT at its start now,
-		   and ungetc() was used to push back the first newline,
-		   which makes the current stream position formally undefined,
-		   and a x-platform nightmare.
-		   Unfortunately, we have no direct way to know whether -x
-		   was specified.  So we use a terrible hack:  if the current
-		   stream position is not 0, we assume -x was specified, and
-		   give up.  Bug 132850 on SourceForge spells out the
-		   hopelessness of trying anything else (fseek and ftell
-		   don't work predictably x-platform for text-mode files).
-		*/
-		int ispyc = 0;
-		if (ftell(fp) == 0) {
-			if (fread(buf, 1, 2, fp) == 2 &&
-			    ((unsigned int)buf[1]<<8 | buf[0]) == halfmagic)
-				ispyc = 1;
-			rewind(fp);
-		}
-		return ispyc;
-	}
-	return 0;
+    if (strcmp(ext, ".pyc") == 0 || strcmp(ext, ".pyo") == 0)
+        return 1;
+
+    /* Only look into the file if we are allowed to close it, since
+       it then should also be seekable. */
+    if (closeit) {
+        /* Read only two bytes of the magic. If the file was opened in
+           text mode, the bytes 3 and 4 of the magic (\r\n) might not
+           be read as they are on disk. */
+        unsigned int halfmagic = PyImport_GetMagicNumber() & 0xFFFF;
+        unsigned char buf[2];
+        /* Mess:  In case of -x, the stream is NOT at its start now,
+           and ungetc() was used to push back the first newline,
+           which makes the current stream position formally undefined,
+           and a x-platform nightmare.
+           Unfortunately, we have no direct way to know whether -x
+           was specified.  So we use a terrible hack:  if the current
+           stream position is not 0, we assume -x was specified, and
+           give up.  Bug 132850 on SourceForge spells out the
+           hopelessness of trying anything else (fseek and ftell
+           don't work predictably x-platform for text-mode files).
+        */
+        int ispyc = 0;
+        if (ftell(fp) == 0) {
+            if (fread(buf, 1, 2, fp) == 2 &&
+                ((unsigned int)buf[1]<<8 | buf[0]) == halfmagic)
+                ispyc = 1;
+            rewind(fp);
+        }
+        return ispyc;
+    }
+    return 0;
 }
 
 int
 PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,
-			PyCompilerFlags *flags)
-{
-	PyObject *m, *d, *v;
-	const char *ext;
-	int set_file_name = 0, ret, len;
-
-	m = PyImport_AddModule("__main__");
-	if (m == NULL)
-		return -1;
-	d = PyModule_GetDict(m);
-	if (PyDict_GetItemString(d, "__file__") == NULL) {
-		PyObject *f = PyString_FromString(filename);
-		if (f == NULL)
-			return -1;
-		if (PyDict_SetItemString(d, "__file__", f) < 0) {
-			Py_DECREF(f);
-			return -1;
-		}
-		set_file_name = 1;
-		Py_DECREF(f);
-	}
-	len = strlen(filename);
-	ext = filename + len - (len > 4 ? 4 : 0);
-	if (maybe_pyc_file(fp, filename, ext, closeit)) {
-		/* Try to run a pyc file. First, re-open in binary */
-		if (closeit)
-			fclose(fp);
-		if ((fp = fopen(filename, "rb")) == NULL) {
-			fprintf(stderr, "python: Can't reopen .pyc file\n");
-			ret = -1;
-			goto done;
-		}
-		/* Turn on optimization if a .pyo file is given */
-		if (strcmp(ext, ".pyo") == 0)
-			Py_OptimizeFlag = 1;
-		v = run_pyc_file(fp, filename, d, d, flags);
-	} else {
-		v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d,
-				      closeit, flags);
-	}
-	if (v == NULL) {
-		PyErr_Print();
-		ret = -1;
-		goto done;
-	}
-	Py_DECREF(v);
-	if (Py_FlushLine())
-		PyErr_Clear();
-	ret = 0;
+                        PyCompilerFlags *flags)
+{
+    PyObject *m, *d, *v;
+    const char *ext;
+    int set_file_name = 0, ret, len;
+
+    m = PyImport_AddModule("__main__");
+    if (m == NULL)
+        return -1;
+    d = PyModule_GetDict(m);
+    if (PyDict_GetItemString(d, "__file__") == NULL) {
+        PyObject *f = PyString_FromString(filename);
+        if (f == NULL)
+            return -1;
+        if (PyDict_SetItemString(d, "__file__", f) < 0) {
+            Py_DECREF(f);
+            return -1;
+        }
+        set_file_name = 1;
+        Py_DECREF(f);
+    }
+    len = strlen(filename);
+    ext = filename + len - (len > 4 ? 4 : 0);
+    if (maybe_pyc_file(fp, filename, ext, closeit)) {
+        /* Try to run a pyc file. First, re-open in binary */
+        if (closeit)
+            fclose(fp);
+        if ((fp = fopen(filename, "rb")) == NULL) {
+            fprintf(stderr, "python: Can't reopen .pyc file\n");
+            ret = -1;
+            goto done;
+        }
+        /* Turn on optimization if a .pyo file is given */
+        if (strcmp(ext, ".pyo") == 0)
+            Py_OptimizeFlag = 1;
+        v = run_pyc_file(fp, filename, d, d, flags);
+    } else {
+        v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d,
+                              closeit, flags);
+    }
+    if (v == NULL) {
+        PyErr_Print();
+        ret = -1;
+        goto done;
+    }
+    Py_DECREF(v);
+    if (Py_FlushLine())
+        PyErr_Clear();
+    ret = 0;
   done:
-	if (set_file_name && PyDict_DelItemString(d, "__file__"))
-		PyErr_Clear();
-	return ret;
+    if (set_file_name && PyDict_DelItemString(d, "__file__"))
+        PyErr_Clear();
+    return ret;
 }
 
 int
 PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags)
 {
-	PyObject *m, *d, *v;
-	m = PyImport_AddModule("__main__");
-	if (m == NULL)
-		return -1;
-	d = PyModule_GetDict(m);
-	v = PyRun_StringFlags(command, Py_file_input, d, d, flags);
-	if (v == NULL) {
-		PyErr_Print();
-		return -1;
-	}
-	Py_DECREF(v);
-	if (Py_FlushLine())
-		PyErr_Clear();
-	return 0;
+    PyObject *m, *d, *v;
+    m = PyImport_AddModule("__main__");
+    if (m == NULL)
+        return -1;
+    d = PyModule_GetDict(m);
+    v = PyRun_StringFlags(command, Py_file_input, d, d, flags);
+    if (v == NULL) {
+        PyErr_Print();
+        return -1;
+    }
+    Py_DECREF(v);
+    if (Py_FlushLine())
+        PyErr_Clear();
+    return 0;
 }
 
 static int
 parse_syntax_error(PyObject *err, PyObject **message, const char **filename,
-		   int *lineno, int *offset, const char **text)
-{
-	long hold;
-	PyObject *v;
-
-	/* old style errors */
-	if (PyTuple_Check(err))
-		return PyArg_ParseTuple(err, "O(ziiz)", message, filename,
-					lineno, offset, text);
-
-	/* new style errors.  `err' is an instance */
-
-	if (! (v = PyObject_GetAttrString(err, "msg")))
-		goto finally;
-	*message = v;
-
-	if (!(v = PyObject_GetAttrString(err, "filename")))
-		goto finally;
-	if (v == Py_None)
-		*filename = NULL;
-	else if (! (*filename = PyString_AsString(v)))
-		goto finally;
-
-	Py_DECREF(v);
-	if (!(v = PyObject_GetAttrString(err, "lineno")))
-		goto finally;
-	hold = PyInt_AsLong(v);
-	Py_DECREF(v);
-	v = NULL;
-	if (hold < 0 && PyErr_Occurred())
-		goto finally;
-	*lineno = (int)hold;
-
-	if (!(v = PyObject_GetAttrString(err, "offset")))
-		goto finally;
-	if (v == Py_None) {
-		*offset = -1;
-		Py_DECREF(v);
-		v = NULL;
-	} else {
-		hold = PyInt_AsLong(v);
-		Py_DECREF(v);
-		v = NULL;
-		if (hold < 0 && PyErr_Occurred())
-			goto finally;
-		*offset = (int)hold;
-	}
-
-	if (!(v = PyObject_GetAttrString(err, "text")))
-		goto finally;
-	if (v == Py_None)
-		*text = NULL;
-	else if (! (*text = PyString_AsString(v)))
-		goto finally;
-	Py_DECREF(v);
-	return 1;
+                   int *lineno, int *offset, const char **text)
+{
+    long hold;
+    PyObject *v;
+
+    /* old style errors */
+    if (PyTuple_Check(err))
+        return PyArg_ParseTuple(err, "O(ziiz)", message, filename,
+                                lineno, offset, text);
+
+    /* new style errors.  `err' is an instance */
+
+    if (! (v = PyObject_GetAttrString(err, "msg")))
+        goto finally;
+    *message = v;
+
+    if (!(v = PyObject_GetAttrString(err, "filename")))
+        goto finally;
+    if (v == Py_None)
+        *filename = NULL;
+    else if (! (*filename = PyString_AsString(v)))
+        goto finally;
+
+    Py_DECREF(v);
+    if (!(v = PyObject_GetAttrString(err, "lineno")))
+        goto finally;
+    hold = PyInt_AsLong(v);
+    Py_DECREF(v);
+    v = NULL;
+    if (hold < 0 && PyErr_Occurred())
+        goto finally;
+    *lineno = (int)hold;
+
+    if (!(v = PyObject_GetAttrString(err, "offset")))
+        goto finally;
+    if (v == Py_None) {
+        *offset = -1;
+        Py_DECREF(v);
+        v = NULL;
+    } else {
+        hold = PyInt_AsLong(v);
+        Py_DECREF(v);
+        v = NULL;
+        if (hold < 0 && PyErr_Occurred())
+            goto finally;
+        *offset = (int)hold;
+    }
+
+    if (!(v = PyObject_GetAttrString(err, "text")))
+        goto finally;
+    if (v == Py_None)
+        *text = NULL;
+    else if (! (*text = PyString_AsString(v)))
+        goto finally;
+    Py_DECREF(v);
+    return 1;
 
 finally:
-	Py_XDECREF(v);
-	return 0;
+    Py_XDECREF(v);
+    return 0;
 }
 
 void
 PyErr_Print(void)
 {
-	PyErr_PrintEx(1);
+    PyErr_PrintEx(1);
 }
 
 static void
 print_error_text(PyObject *f, int offset, const char *text)
 {
-	char *nl;
-	if (offset >= 0) {
-		if (offset > 0 && offset == (int)strlen(text))
-			offset--;
-		for (;;) {
-			nl = strchr(text, '\n');
-			if (nl == NULL || nl-text >= offset)
-				break;
-			offset -= (int)(nl+1-text);
-			text = nl+1;
-		}
-		while (*text == ' ' || *text == '\t') {
-			text++;
-			offset--;
-		}
-	}
-	PyFile_WriteString("    ", f);
-	PyFile_WriteString(text, f);
-	if (*text == '\0' || text[strlen(text)-1] != '\n')
-		PyFile_WriteString("\n", f);
-	if (offset == -1)
-		return;
-	PyFile_WriteString("    ", f);
-	offset--;
-	while (offset > 0) {
-		PyFile_WriteString(" ", f);
-		offset--;
-	}
-	PyFile_WriteString("^\n", f);
+    char *nl;
+    if (offset >= 0) {
+        if (offset > 0 && offset == (int)strlen(text))
+            offset--;
+        for (;;) {
+            nl = strchr(text, '\n');
+            if (nl == NULL || nl-text >= offset)
+                break;
+            offset -= (int)(nl+1-text);
+            text = nl+1;
+        }
+        while (*text == ' ' || *text == '\t') {
+            text++;
+            offset--;
+        }
+    }
+    PyFile_WriteString("    ", f);
+    PyFile_WriteString(text, f);
+    if (*text == '\0' || text[strlen(text)-1] != '\n')
+        PyFile_WriteString("\n", f);
+    if (offset == -1)
+        return;
+    PyFile_WriteString("    ", f);
+    offset--;
+    while (offset > 0) {
+        PyFile_WriteString(" ", f);
+        offset--;
+    }
+    PyFile_WriteString("^\n", f);
 }
 
 static void
 handle_system_exit(void)
 {
-	PyObject *exception, *value, *tb;
-	int exitcode = 0;
-
-	if (Py_InspectFlag)
-		/* Don't exit if -i flag was given. This flag is set to 0
-		 * when entering interactive mode for inspecting. */
-		return;
-
-	PyErr_Fetch(&exception, &value, &tb);
-	if (Py_FlushLine())
-		PyErr_Clear();
-	fflush(stdout);
-	if (value == NULL || value == Py_None)
-		goto done;
-	if (PyExceptionInstance_Check(value)) {
-		/* The error code should be in the `code' attribute. */
-		PyObject *code = PyObject_GetAttrString(value, "code");
-		if (code) {
-			Py_DECREF(value);
-			value = code;
-			if (value == Py_None)
-				goto done;
-		}
-		/* If we failed to dig out the 'code' attribute,
-		   just let the else clause below print the error. */
-	}
-	if (PyInt_Check(value))
-		exitcode = (int)PyInt_AsLong(value);
-	else {
-		PyObject_Print(value, stderr, Py_PRINT_RAW);
-		PySys_WriteStderr("\n");
-		exitcode = 1;
-	}
+    PyObject *exception, *value, *tb;
+    int exitcode = 0;
+
+    if (Py_InspectFlag)
+        /* Don't exit if -i flag was given. This flag is set to 0
+         * when entering interactive mode for inspecting. */
+        return;
+
+    PyErr_Fetch(&exception, &value, &tb);
+    if (Py_FlushLine())
+        PyErr_Clear();
+    fflush(stdout);
+    if (value == NULL || value == Py_None)
+        goto done;
+    if (PyExceptionInstance_Check(value)) {
+        /* The error code should be in the `code' attribute. */
+        PyObject *code = PyObject_GetAttrString(value, "code");
+        if (code) {
+            Py_DECREF(value);
+            value = code;
+            if (value == Py_None)
+                goto done;
+        }
+        /* If we failed to dig out the 'code' attribute,
+           just let the else clause below print the error. */
+    }
+    if (PyInt_Check(value))
+        exitcode = (int)PyInt_AsLong(value);
+    else {
+        PyObject_Print(value, stderr, Py_PRINT_RAW);
+        PySys_WriteStderr("\n");
+        exitcode = 1;
+    }
  done:
-	/* Restore and clear the exception info, in order to properly decref
-	 * the exception, value, and traceback.	 If we just exit instead,
-	 * these leak, which confuses PYTHONDUMPREFS output, and may prevent
-	 * some finalizers from running.
-	 */
-	PyErr_Restore(exception, value, tb);
-	PyErr_Clear();
-	Py_Exit(exitcode);
-	/* NOTREACHED */
+    /* Restore and clear the exception info, in order to properly decref
+     * the exception, value, and traceback.      If we just exit instead,
+     * these leak, which confuses PYTHONDUMPREFS output, and may prevent
+     * some finalizers from running.
+     */
+    PyErr_Restore(exception, value, tb);
+    PyErr_Clear();
+    Py_Exit(exitcode);
+    /* NOTREACHED */
 }
 
 void
 PyErr_PrintEx(int set_sys_last_vars)
 {
-	PyObject *exception, *v, *tb, *hook;
-
-	if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
-		handle_system_exit();
-	}
-	PyErr_Fetch(&exception, &v, &tb);
-	if (exception == NULL)
-		return;
-	PyErr_NormalizeException(&exception, &v, &tb);
-	if (exception == NULL)
-		return;
-	/* Now we know v != NULL too */
-	if (set_sys_last_vars) {
-		PySys_SetObject("last_type", exception);
-		PySys_SetObject("last_value", v);
-		PySys_SetObject("last_traceback", tb);
-	}
-	hook = PySys_GetObject("excepthook");
-	if (hook) {
-		PyObject *args = PyTuple_Pack(3,
-		    exception, v, tb ? tb : Py_None);
-		PyObject *result = PyEval_CallObject(hook, args);
-		if (result == NULL) {
-			PyObject *exception2, *v2, *tb2;
-			if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
-				handle_system_exit();
-			}
-			PyErr_Fetch(&exception2, &v2, &tb2);
-			PyErr_NormalizeException(&exception2, &v2, &tb2);
-			/* It should not be possible for exception2 or v2
-			   to be NULL. However PyErr_Display() can't
-			   tolerate NULLs, so just be safe. */
-			if (exception2 == NULL) {
-				exception2 = Py_None;
-				Py_INCREF(exception2);
-			}
-			if (v2 == NULL) {
-				v2 = Py_None;
-				Py_INCREF(v2);
-			}
-			if (Py_FlushLine())
-				PyErr_Clear();
-			fflush(stdout);
-			PySys_WriteStderr("Error in sys.excepthook:\n");
-			PyErr_Display(exception2, v2, tb2);
-			PySys_WriteStderr("\nOriginal exception was:\n");
-			PyErr_Display(exception, v, tb);
-			Py_DECREF(exception2);
-			Py_DECREF(v2);
-			Py_XDECREF(tb2);
-		}
-		Py_XDECREF(result);
-		Py_XDECREF(args);
-	} else {
-		PySys_WriteStderr("sys.excepthook is missing\n");
-		PyErr_Display(exception, v, tb);
-	}
-	Py_XDECREF(exception);
-	Py_XDECREF(v);
-	Py_XDECREF(tb);
+    PyObject *exception, *v, *tb, *hook;
+
+    if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
+        handle_system_exit();
+    }
+    PyErr_Fetch(&exception, &v, &tb);
+    if (exception == NULL)
+        return;
+    PyErr_NormalizeException(&exception, &v, &tb);
+    if (exception == NULL)
+        return;
+    /* Now we know v != NULL too */
+    if (set_sys_last_vars) {
+        PySys_SetObject("last_type", exception);
+        PySys_SetObject("last_value", v);
+        PySys_SetObject("last_traceback", tb);
+    }
+    hook = PySys_GetObject("excepthook");
+    if (hook) {
+        PyObject *args = PyTuple_Pack(3,
+            exception, v, tb ? tb : Py_None);
+        PyObject *result = PyEval_CallObject(hook, args);
+        if (result == NULL) {
+            PyObject *exception2, *v2, *tb2;
+            if (PyErr_ExceptionMatches(PyExc_SystemExit)) {
+                handle_system_exit();
+            }
+            PyErr_Fetch(&exception2, &v2, &tb2);
+            PyErr_NormalizeException(&exception2, &v2, &tb2);
+            /* It should not be possible for exception2 or v2
+               to be NULL. However PyErr_Display() can't
+               tolerate NULLs, so just be safe. */
+            if (exception2 == NULL) {
+                exception2 = Py_None;
+                Py_INCREF(exception2);
+            }
+            if (v2 == NULL) {
+                v2 = Py_None;
+                Py_INCREF(v2);
+            }
+            if (Py_FlushLine())
+                PyErr_Clear();
+            fflush(stdout);
+            PySys_WriteStderr("Error in sys.excepthook:\n");
+            PyErr_Display(exception2, v2, tb2);
+            PySys_WriteStderr("\nOriginal exception was:\n");
+            PyErr_Display(exception, v, tb);
+            Py_DECREF(exception2);
+            Py_DECREF(v2);
+            Py_XDECREF(tb2);
+        }
+        Py_XDECREF(result);
+        Py_XDECREF(args);
+    } else {
+        PySys_WriteStderr("sys.excepthook is missing\n");
+        PyErr_Display(exception, v, tb);
+    }
+    Py_XDECREF(exception);
+    Py_XDECREF(v);
+    Py_XDECREF(tb);
 }
 
 void
 PyErr_Display(PyObject *exception, PyObject *value, PyObject *tb)
 {
-	int err = 0;
-	PyObject *f = PySys_GetObject("stderr");
-	Py_INCREF(value);
-	if (f == NULL)
-		fprintf(stderr, "lost sys.stderr\n");
-	else {
-		if (Py_FlushLine())
-			PyErr_Clear();
-		fflush(stdout);
-		if (tb && tb != Py_None)
-			err = PyTraceBack_Print(tb, f);
-		if (err == 0 &&
-		    PyObject_HasAttrString(value, "print_file_and_line"))
-		{
-			PyObject *message;
-			const char *filename, *text;
-			int lineno, offset;
-			if (!parse_syntax_error(value, &message, &filename,
-						&lineno, &offset, &text))
-				PyErr_Clear();
-			else {
-				char buf[10];
-				PyFile_WriteString("  File \"", f);
-				if (filename == NULL)
-					PyFile_WriteString("<string>", f);
-				else
-					PyFile_WriteString(filename, f);
-				PyFile_WriteString("\", line ", f);
-				PyOS_snprintf(buf, sizeof(buf), "%d", lineno);
-				PyFile_WriteString(buf, f);
-				PyFile_WriteString("\n", f);
-				if (text != NULL)
-					print_error_text(f, offset, text);
-				Py_DECREF(value);
-				value = message;
-				/* Can't be bothered to check all those
-				   PyFile_WriteString() calls */
-				if (PyErr_Occurred())
-					err = -1;
-			}
-		}
-		if (err) {
-			/* Don't do anything else */
-		}
-		else if (PyExceptionClass_Check(exception)) {
-			PyObject* moduleName;
-			char* className = PyExceptionClass_Name(exception);
-			if (className != NULL) {
-				char *dot = strrchr(className, '.');
-				if (dot != NULL)
-					className = dot+1;
-			}
-
-			moduleName = PyObject_GetAttrString(exception, "__module__");
-			if (moduleName == NULL)
-				err = PyFile_WriteString("<unknown>", f);
-			else {
-				char* modstr = PyString_AsString(moduleName);
-				if (modstr && strcmp(modstr, "exceptions"))
-				{
-					err = PyFile_WriteString(modstr, f);
-					err += PyFile_WriteString(".", f);
-				}
-				Py_DECREF(moduleName);
-			}
-			if (err == 0) {
-				if (className == NULL)
-				      err = PyFile_WriteString("<unknown>", f);
-				else
-				      err = PyFile_WriteString(className, f);
-			}
-		}
-		else
-			err = PyFile_WriteObject(exception, f, Py_PRINT_RAW);
-		if (err == 0 && (value != Py_None)) {
-			PyObject *s = PyObject_Str(value);
-			/* only print colon if the str() of the
-			   object is not the empty string
-			*/
-			if (s == NULL)
-				err = -1;
-			else if (!PyString_Check(s) ||
-				 PyString_GET_SIZE(s) != 0)
-				err = PyFile_WriteString(": ", f);
-			if (err == 0)
-			  err = PyFile_WriteObject(s, f, Py_PRINT_RAW);
-			Py_XDECREF(s);
-		}
-		/* try to write a newline in any case */
-		err += PyFile_WriteString("\n", f);
-	}
-	Py_DECREF(value);
-	/* If an error happened here, don't show it.
-	   XXX This is wrong, but too many callers rely on this behavior. */
-	if (err != 0)
-		PyErr_Clear();
+    int err = 0;
+    PyObject *f = PySys_GetObject("stderr");
+    Py_INCREF(value);
+    if (f == NULL)
+        fprintf(stderr, "lost sys.stderr\n");
+    else {
+        if (Py_FlushLine())
+            PyErr_Clear();
+        fflush(stdout);
+        if (tb && tb != Py_None)
+            err = PyTraceBack_Print(tb, f);
+        if (err == 0 &&
+            PyObject_HasAttrString(value, "print_file_and_line"))
+        {
+            PyObject *message;
+            const char *filename, *text;
+            int lineno, offset;
+            if (!parse_syntax_error(value, &message, &filename,
+                                    &lineno, &offset, &text))
+                PyErr_Clear();
+            else {
+                char buf[10];
+                PyFile_WriteString("  File \"", f);
+                if (filename == NULL)
+                    PyFile_WriteString("<string>", f);
+                else
+                    PyFile_WriteString(filename, f);
+                PyFile_WriteString("\", line ", f);
+                PyOS_snprintf(buf, sizeof(buf), "%d", lineno);
+                PyFile_WriteString(buf, f);
+                PyFile_WriteString("\n", f);
+                if (text != NULL)
+                    print_error_text(f, offset, text);
+                Py_DECREF(value);
+                value = message;
+                /* Can't be bothered to check all those
+                   PyFile_WriteString() calls */
+                if (PyErr_Occurred())
+                    err = -1;
+            }
+        }
+        if (err) {
+            /* Don't do anything else */
+        }
+        else if (PyExceptionClass_Check(exception)) {
+            PyObject* moduleName;
+            char* className = PyExceptionClass_Name(exception);
+            if (className != NULL) {
+                char *dot = strrchr(className, '.');
+                if (dot != NULL)
+                    className = dot+1;
+            }
+
+            moduleName = PyObject_GetAttrString(exception, "__module__");
+            if (moduleName == NULL)
+                err = PyFile_WriteString("<unknown>", f);
+            else {
+                char* modstr = PyString_AsString(moduleName);
+                if (modstr && strcmp(modstr, "exceptions"))
+                {
+                    err = PyFile_WriteString(modstr, f);
+                    err += PyFile_WriteString(".", f);
+                }
+                Py_DECREF(moduleName);
+            }
+            if (err == 0) {
+                if (className == NULL)
+                      err = PyFile_WriteString("<unknown>", f);
+                else
+                      err = PyFile_WriteString(className, f);
+            }
+        }
+        else
+            err = PyFile_WriteObject(exception, f, Py_PRINT_RAW);
+        if (err == 0 && (value != Py_None)) {
+            PyObject *s = PyObject_Str(value);
+            /* only print colon if the str() of the
+               object is not the empty string
+            */
+            if (s == NULL)
+                err = -1;
+            else if (!PyString_Check(s) ||
+                     PyString_GET_SIZE(s) != 0)
+                err = PyFile_WriteString(": ", f);
+            if (err == 0)
+              err = PyFile_WriteObject(s, f, Py_PRINT_RAW);
+            Py_XDECREF(s);
+        }
+        /* try to write a newline in any case */
+        err += PyFile_WriteString("\n", f);
+    }
+    Py_DECREF(value);
+    /* If an error happened here, don't show it.
+       XXX This is wrong, but too many callers rely on this behavior. */
+    if (err != 0)
+        PyErr_Clear();
 }
 
 PyObject *
 PyRun_StringFlags(const char *str, int start, PyObject *globals,
-		  PyObject *locals, PyCompilerFlags *flags)
+                  PyObject *locals, PyCompilerFlags *flags)
 {
-	PyObject *ret = NULL;
-	mod_ty mod;
-	PyArena *arena = PyArena_New();
-	if (arena == NULL)
-		return NULL;
+    PyObject *ret = NULL;
+    mod_ty mod;
+    PyArena *arena = PyArena_New();
+    if (arena == NULL)
+        return NULL;
 
-	mod = PyParser_ASTFromString(str, "<string>", start, flags, arena);
-	if (mod != NULL)
-		ret = run_mod(mod, "<string>", globals, locals, flags, arena);
-	PyArena_Free(arena);
-	return ret;
+    mod = PyParser_ASTFromString(str, "<string>", start, flags, arena);
+    if (mod != NULL)
+        ret = run_mod(mod, "<string>", globals, locals, flags, arena);
+    PyArena_Free(arena);
+    return ret;
 }
 
 PyObject *
 PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals,
-		  PyObject *locals, int closeit, PyCompilerFlags *flags)
-{
-	PyObject *ret;
-	mod_ty mod;
-	PyArena *arena = PyArena_New();
-	if (arena == NULL)
-		return NULL;
-
-	mod = PyParser_ASTFromFile(fp, filename, start, 0, 0,
-				   flags, NULL, arena);
-	if (closeit)
-		fclose(fp);
-	if (mod == NULL) {
-		PyArena_Free(arena);
-		return NULL;
-	}
-	ret = run_mod(mod, filename, globals, locals, flags, arena);
-	PyArena_Free(arena);
-	return ret;
+                  PyObject *locals, int closeit, PyCompilerFlags *flags)
+{
+    PyObject *ret;
+    mod_ty mod;
+    PyArena *arena = PyArena_New();
+    if (arena == NULL)
+        return NULL;
+
+    mod = PyParser_ASTFromFile(fp, filename, start, 0, 0,
+                               flags, NULL, arena);
+    if (closeit)
+        fclose(fp);
+    if (mod == NULL) {
+        PyArena_Free(arena);
+        return NULL;
+    }
+    ret = run_mod(mod, filename, globals, locals, flags, arena);
+    PyArena_Free(arena);
+    return ret;
 }
 
 static PyObject *
 run_mod(mod_ty mod, const char *filename, PyObject *globals, PyObject *locals,
-	 PyCompilerFlags *flags, PyArena *arena)
+         PyCompilerFlags *flags, PyArena *arena)
 {
-	PyCodeObject *co;
-	PyObject *v;
-	co = PyAST_Compile(mod, filename, flags, arena);
-	if (co == NULL)
-		return NULL;
-	v = PyEval_EvalCode(co, globals, locals);
-	Py_DECREF(co);
-	return v;
+    PyCodeObject *co;
+    PyObject *v;
+    co = PyAST_Compile(mod, filename, flags, arena);
+    if (co == NULL)
+        return NULL;
+    v = PyEval_EvalCode(co, globals, locals);
+    Py_DECREF(co);
+    return v;
 }
 
 static PyObject *
 run_pyc_file(FILE *fp, const char *filename, PyObject *globals,
-	     PyObject *locals, PyCompilerFlags *flags)
-{
-	PyCodeObject *co;
-	PyObject *v;
-	long magic;
-	long PyImport_GetMagicNumber(void);
-
-	magic = PyMarshal_ReadLongFromFile(fp);
-	if (magic != PyImport_GetMagicNumber()) {
-		PyErr_SetString(PyExc_RuntimeError,
-			   "Bad magic number in .pyc file");
-		return NULL;
-	}
-	(void) PyMarshal_ReadLongFromFile(fp);
-	v = PyMarshal_ReadLastObjectFromFile(fp);
-	fclose(fp);
-	if (v == NULL || !PyCode_Check(v)) {
-		Py_XDECREF(v);
-		PyErr_SetString(PyExc_RuntimeError,
-			   "Bad code object in .pyc file");
-		return NULL;
-	}
-	co = (PyCodeObject *)v;
-	v = PyEval_EvalCode(co, globals, locals);
-	if (v && flags)
-		flags->cf_flags |= (co->co_flags & PyCF_MASK);
-	Py_DECREF(co);
-	return v;
+             PyObject *locals, PyCompilerFlags *flags)
+{
+    PyCodeObject *co;
+    PyObject *v;
+    long magic;
+    long PyImport_GetMagicNumber(void);
+
+    magic = PyMarshal_ReadLongFromFile(fp);
+    if (magic != PyImport_GetMagicNumber()) {
+        PyErr_SetString(PyExc_RuntimeError,
+                   "Bad magic number in .pyc file");
+        return NULL;
+    }
+    (void) PyMarshal_ReadLongFromFile(fp);
+    v = PyMarshal_ReadLastObjectFromFile(fp);
+    fclose(fp);
+    if (v == NULL || !PyCode_Check(v)) {
+        Py_XDECREF(v);
+        PyErr_SetString(PyExc_RuntimeError,
+                   "Bad code object in .pyc file");
+        return NULL;
+    }
+    co = (PyCodeObject *)v;
+    v = PyEval_EvalCode(co, globals, locals);
+    if (v && flags)
+        flags->cf_flags |= (co->co_flags & PyCF_MASK);
+    Py_DECREF(co);
+    return v;
 }
 
 PyObject *
 Py_CompileStringFlags(const char *str, const char *filename, int start,
-		      PyCompilerFlags *flags)
-{
-	PyCodeObject *co;
-	mod_ty mod;
-	PyArena *arena = PyArena_New();
-	if (arena == NULL)
-		return NULL;
-
-	mod = PyParser_ASTFromString(str, filename, start, flags, arena);
-	if (mod == NULL) {
-		PyArena_Free(arena);
-		return NULL;
-	}
-	if (flags && (flags->cf_flags & PyCF_ONLY_AST)) {
-		PyObject *result = PyAST_mod2obj(mod);
-		PyArena_Free(arena);
-		return result;
-	}
-	co = PyAST_Compile(mod, filename, flags, arena);
-	PyArena_Free(arena);
-	return (PyObject *)co;
+                      PyCompilerFlags *flags)
+{
+    PyCodeObject *co;
+    mod_ty mod;
+    PyArena *arena = PyArena_New();
+    if (arena == NULL)
+        return NULL;
+
+    mod = PyParser_ASTFromString(str, filename, start, flags, arena);
+    if (mod == NULL) {
+        PyArena_Free(arena);
+        return NULL;
+    }
+    if (flags && (flags->cf_flags & PyCF_ONLY_AST)) {
+        PyObject *result = PyAST_mod2obj(mod);
+        PyArena_Free(arena);
+        return result;
+    }
+    co = PyAST_Compile(mod, filename, flags, arena);
+    PyArena_Free(arena);
+    return (PyObject *)co;
 }
 
 struct symtable *
 Py_SymtableString(const char *str, const char *filename, int start)
 {
-	struct symtable *st;
-	mod_ty mod;
-	PyCompilerFlags flags;
-	PyArena *arena = PyArena_New();
-	if (arena == NULL)
-		return NULL;
+    struct symtable *st;
+    mod_ty mod;
+    PyCompilerFlags flags;
+    PyArena *arena = PyArena_New();
+    if (arena == NULL)
+        return NULL;
 
-	flags.cf_flags = 0;
+    flags.cf_flags = 0;
 
-	mod = PyParser_ASTFromString(str, filename, start, &flags, arena);
-	if (mod == NULL) {
-		PyArena_Free(arena);
-		return NULL;
-	}
-	st = PySymtable_Build(mod, filename, 0);
-	PyArena_Free(arena);
-	return st;
+    mod = PyParser_ASTFromString(str, filename, start, &flags, arena);
+    if (mod == NULL) {
+        PyArena_Free(arena);
+        return NULL;
+    }
+    st = PySymtable_Build(mod, filename, 0);
+    PyArena_Free(arena);
+    return st;
 }
 
 /* Preferred access to parser is through AST. */
 mod_ty
 PyParser_ASTFromString(const char *s, const char *filename, int start,
-		       PyCompilerFlags *flags, PyArena *arena)
-{
-	mod_ty mod;
-	PyCompilerFlags localflags;
-	perrdetail err;
-	int iflags = PARSER_FLAGS(flags);
-
-	node *n = PyParser_ParseStringFlagsFilenameEx(s, filename,
-					&_PyParser_Grammar, start, &err,
-					&iflags);
-	if (flags == NULL) {
-		localflags.cf_flags = 0;
-		flags = &localflags;
-	}
-	if (n) {
-		flags->cf_flags |= iflags & PyCF_MASK;
-		mod = PyAST_FromNode(n, flags, filename, arena);
-		PyNode_Free(n);
-		return mod;
-	}
-	else {
-		err_input(&err);
-		return NULL;
-	}
+                       PyCompilerFlags *flags, PyArena *arena)
+{
+    mod_ty mod;
+    PyCompilerFlags localflags;
+    perrdetail err;
+    int iflags = PARSER_FLAGS(flags);
+
+    node *n = PyParser_ParseStringFlagsFilenameEx(s, filename,
+                                    &_PyParser_Grammar, start, &err,
+                                    &iflags);
+    if (flags == NULL) {
+        localflags.cf_flags = 0;
+        flags = &localflags;
+    }
+    if (n) {
+        flags->cf_flags |= iflags & PyCF_MASK;
+        mod = PyAST_FromNode(n, flags, filename, arena);
+        PyNode_Free(n);
+        return mod;
+    }
+    else {
+        err_input(&err);
+        return NULL;
+    }
 }
 
 mod_ty
 PyParser_ASTFromFile(FILE *fp, const char *filename, int start, char *ps1,
-		     char *ps2, PyCompilerFlags *flags, int *errcode,
-		     PyArena *arena)
-{
-	mod_ty mod;
-	PyCompilerFlags localflags;
-	perrdetail err;
-	int iflags = PARSER_FLAGS(flags);
-
-	node *n = PyParser_ParseFileFlagsEx(fp, filename, &_PyParser_Grammar,
-				start, ps1, ps2, &err, &iflags);
-	if (flags == NULL) {
-		localflags.cf_flags = 0;
-		flags = &localflags;
-	}
-	if (n) {
-		flags->cf_flags |= iflags & PyCF_MASK;
-		mod = PyAST_FromNode(n, flags, filename, arena);
-		PyNode_Free(n);
-		return mod;
-	}
-	else {
-		err_input(&err);
-		if (errcode)
-			*errcode = err.error;
-		return NULL;
-	}
+                     char *ps2, PyCompilerFlags *flags, int *errcode,
+                     PyArena *arena)
+{
+    mod_ty mod;
+    PyCompilerFlags localflags;
+    perrdetail err;
+    int iflags = PARSER_FLAGS(flags);
+
+    node *n = PyParser_ParseFileFlagsEx(fp, filename, &_PyParser_Grammar,
+                            start, ps1, ps2, &err, &iflags);
+    if (flags == NULL) {
+        localflags.cf_flags = 0;
+        flags = &localflags;
+    }
+    if (n) {
+        flags->cf_flags |= iflags & PyCF_MASK;
+        mod = PyAST_FromNode(n, flags, filename, arena);
+        PyNode_Free(n);
+        return mod;
+    }
+    else {
+        err_input(&err);
+        if (errcode)
+            *errcode = err.error;
+        return NULL;
+    }
 }
 
 /* Simplified interface to parsefile -- return node or set exception */
@@ -1485,13 +1485,13 @@ PyParser_ASTFromFile(FILE *fp, const char *filename, int start, char *ps1,
 node *
 PyParser_SimpleParseFileFlags(FILE *fp, const char *filename, int start, int flags)
 {
-	perrdetail err;
-	node *n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar,
-					  start, NULL, NULL, &err, flags);
-	if (n == NULL)
-		err_input(&err);
+    perrdetail err;
+    node *n = PyParser_ParseFileFlags(fp, filename, &_PyParser_Grammar,
+                                      start, NULL, NULL, &err, flags);
+    if (n == NULL)
+        err_input(&err);
 
-	return n;
+    return n;
 }
 
 /* Simplified interface to parsestring -- return node or set exception */
@@ -1499,30 +1499,30 @@ PyParser_SimpleParseFileFlags(FILE *fp, const char *filename, int start, int fla
 node *
 PyParser_SimpleParseStringFlags(const char *str, int start, int flags)
 {
-	perrdetail err;
-	node *n = PyParser_ParseStringFlags(str, &_PyParser_Grammar,
-					    start, &err, flags);
-	if (n == NULL)
-		err_input(&err);
-	return n;
+    perrdetail err;
+    node *n = PyParser_ParseStringFlags(str, &_PyParser_Grammar,
+                                        start, &err, flags);
+    if (n == NULL)
+        err_input(&err);
+    return n;
 }
 
 node *
 PyParser_SimpleParseStringFlagsFilename(const char *str, const char *filename,
-					int start, int flags)
+                                        int start, int flags)
 {
-	perrdetail err;
-	node *n = PyParser_ParseStringFlagsFilename(str, filename,
-				&_PyParser_Grammar, start, &err, flags);
-	if (n == NULL)
-		err_input(&err);
-	return n;
+    perrdetail err;
+    node *n = PyParser_ParseStringFlagsFilename(str, filename,
+                            &_PyParser_Grammar, start, &err, flags);
+    if (n == NULL)
+        err_input(&err);
+    return n;
 }
 
 node *
 PyParser_SimpleParseStringFilename(const char *str, const char *filename, int start)
 {
-	return PyParser_SimpleParseStringFlagsFilename(str, filename, start, 0);
+    return PyParser_SimpleParseStringFlagsFilename(str, filename, start, 0);
 }
 
 /* May want to move a more generalized form of this to parsetok.c or
@@ -1531,7 +1531,7 @@ PyParser_SimpleParseStringFilename(const char *str, const char *filename, int st
 void
 PyParser_SetError(perrdetail *err)
 {
-	err_input(err);
+    err_input(err);
 }
 
 /* Set the error appropriate to the given input error code (see errcode.h) */
@@ -1539,98 +1539,98 @@ PyParser_SetError(perrdetail *err)
 static void
 err_input(perrdetail *err)
 {
-	PyObject *v, *w, *errtype;
-	PyObject* u = NULL;
-	char *msg = NULL;
-	errtype = PyExc_SyntaxError;
-	switch (err->error) {
-	case E_ERROR:
-		return;
-	case E_SYNTAX:
-		errtype = PyExc_IndentationError;
-		if (err->expected == INDENT)
-			msg = "expected an indented block";
-		else if (err->token == INDENT)
-			msg = "unexpected indent";
-		else if (err->token == DEDENT)
-			msg = "unexpected unindent";
-		else {
-			errtype = PyExc_SyntaxError;
-			msg = "invalid syntax";
-		}
-		break;
-	case E_TOKEN:
-		msg = "invalid token";
-		break;
-	case E_EOFS:
-		msg = "EOF while scanning triple-quoted string literal";
-		break;
-	case E_EOLS:
-		msg = "EOL while scanning string literal";
-		break;
-	case E_INTR:
-		if (!PyErr_Occurred())
-			PyErr_SetNone(PyExc_KeyboardInterrupt);
-		goto cleanup;
-	case E_NOMEM:
-		PyErr_NoMemory();
-		goto cleanup;
-	case E_EOF:
-		msg = "unexpected EOF while parsing";
-		break;
-	case E_TABSPACE:
-		errtype = PyExc_TabError;
-		msg = "inconsistent use of tabs and spaces in indentation";
-		break;
-	case E_OVERFLOW:
-		msg = "expression too long";
-		break;
-	case E_DEDENT:
-		errtype = PyExc_IndentationError;
-		msg = "unindent does not match any outer indentation level";
-		break;
-	case E_TOODEEP:
-		errtype = PyExc_IndentationError;
-		msg = "too many levels of indentation";
-		break;
-	case E_DECODE: {
-		PyObject *type, *value, *tb;
-		PyErr_Fetch(&type, &value, &tb);
-		if (value != NULL) {
-			u = PyObject_Str(value);
-			if (u != NULL) {
-				msg = PyString_AsString(u);
-			}
-		}
-		if (msg == NULL)
-			msg = "unknown decode error";
-		Py_XDECREF(type);
-		Py_XDECREF(value);
-		Py_XDECREF(tb);
-		break;
-	}
-	case E_LINECONT:
-		msg = "unexpected character after line continuation character";
-		break;
-	default:
-		fprintf(stderr, "error=%d\n", err->error);
-		msg = "unknown parsing error";
-		break;
-	}
-	v = Py_BuildValue("(ziiz)", err->filename,
-			  err->lineno, err->offset, err->text);
-	w = NULL;
-	if (v != NULL)
-		w = Py_BuildValue("(sO)", msg, v);
-	Py_XDECREF(u);
-	Py_XDECREF(v);
-	PyErr_SetObject(errtype, w);
-	Py_XDECREF(w);
+    PyObject *v, *w, *errtype;
+    PyObject* u = NULL;
+    char *msg = NULL;
+    errtype = PyExc_SyntaxError;
+    switch (err->error) {
+    case E_ERROR:
+        return;
+    case E_SYNTAX:
+        errtype = PyExc_IndentationError;
+        if (err->expected == INDENT)
+            msg = "expected an indented block";
+        else if (err->token == INDENT)
+            msg = "unexpected indent";
+        else if (err->token == DEDENT)
+            msg = "unexpected unindent";
+        else {
+            errtype = PyExc_SyntaxError;
+            msg = "invalid syntax";
+        }
+        break;
+    case E_TOKEN:
+        msg = "invalid token";
+        break;
+    case E_EOFS:
+        msg = "EOF while scanning triple-quoted string literal";
+        break;
+    case E_EOLS:
+        msg = "EOL while scanning string literal";
+        break;
+    case E_INTR:
+        if (!PyErr_Occurred())
+            PyErr_SetNone(PyExc_KeyboardInterrupt);
+        goto cleanup;
+    case E_NOMEM:
+        PyErr_NoMemory();
+        goto cleanup;
+    case E_EOF:
+        msg = "unexpected EOF while parsing";
+        break;
+    case E_TABSPACE:
+        errtype = PyExc_TabError;
+        msg = "inconsistent use of tabs and spaces in indentation";
+        break;
+    case E_OVERFLOW:
+        msg = "expression too long";
+        break;
+    case E_DEDENT:
+        errtype = PyExc_IndentationError;
+        msg = "unindent does not match any outer indentation level";
+        break;
+    case E_TOODEEP:
+        errtype = PyExc_IndentationError;
+        msg = "too many levels of indentation";
+        break;
+    case E_DECODE: {
+        PyObject *type, *value, *tb;
+        PyErr_Fetch(&type, &value, &tb);
+        if (value != NULL) {
+            u = PyObject_Str(value);
+            if (u != NULL) {
+                msg = PyString_AsString(u);
+            }
+        }
+        if (msg == NULL)
+            msg = "unknown decode error";
+        Py_XDECREF(type);
+        Py_XDECREF(value);
+        Py_XDECREF(tb);
+        break;
+    }
+    case E_LINECONT:
+        msg = "unexpected character after line continuation character";
+        break;
+    default:
+        fprintf(stderr, "error=%d\n", err->error);
+        msg = "unknown parsing error";
+        break;
+    }
+    v = Py_BuildValue("(ziiz)", err->filename,
+                      err->lineno, err->offset, err->text);
+    w = NULL;
+    if (v != NULL)
+        w = Py_BuildValue("(sO)", msg, v);
+    Py_XDECREF(u);
+    Py_XDECREF(v);
+    PyErr_SetObject(errtype, w);
+    Py_XDECREF(w);
 cleanup:
-	if (err->text != NULL) {
-		PyObject_FREE(err->text);
-		err->text = NULL;
-	}
+    if (err->text != NULL) {
+        PyObject_FREE(err->text);
+        err->text = NULL;
+    }
 }
 
 /* Print fatal error message and abort */
@@ -1638,30 +1638,30 @@ cleanup:
 void
 Py_FatalError(const char *msg)
 {
-	fprintf(stderr, "Fatal Python error: %s\n", msg);
-	fflush(stderr); /* it helps in Windows debug build */
+    fprintf(stderr, "Fatal Python error: %s\n", msg);
+    fflush(stderr); /* it helps in Windows debug build */
 
 #ifdef MS_WINDOWS
-	{
-		size_t len = strlen(msg);
-		WCHAR* buffer;
-		size_t i;
-
-		/* Convert the message to wchar_t. This uses a simple one-to-one
-		conversion, assuming that the this error message actually uses ASCII
-		only. If this ceases to be true, we will have to convert. */
-		buffer = alloca( (len+1) * (sizeof *buffer));
-		for( i=0; i<=len; ++i)
-			buffer[i] = msg[i];
-		OutputDebugStringW(L"Fatal Python error: ");
-		OutputDebugStringW(buffer);
-		OutputDebugStringW(L"\n");
-	}
+    {
+        size_t len = strlen(msg);
+        WCHAR* buffer;
+        size_t i;
+
+        /* Convert the message to wchar_t. This uses a simple one-to-one
+        conversion, assuming that the this error message actually uses ASCII
+        only. If this ceases to be true, we will have to convert. */
+        buffer = alloca( (len+1) * (sizeof *buffer));
+        for( i=0; i<=len; ++i)
+            buffer[i] = msg[i];
+        OutputDebugStringW(L"Fatal Python error: ");
+        OutputDebugStringW(buffer);
+        OutputDebugStringW(L"\n");
+    }
 #ifdef _DEBUG
-	DebugBreak();
+    DebugBreak();
 #endif
 #endif /* MS_WINDOWS */
-	abort();
+    abort();
 }
 
 /* Clean up and exit */
@@ -1678,21 +1678,21 @@ static void
 wait_for_thread_shutdown(void)
 {
 #ifdef WITH_THREAD
-	PyObject *result;
-	PyThreadState *tstate = PyThreadState_GET();
-	PyObject *threading = PyMapping_GetItemString(tstate->interp->modules,
-						      "threading");
-	if (threading == NULL) {
-		/* threading not imported */
-		PyErr_Clear();
-		return;
-	}
-	result = PyObject_CallMethod(threading, "_shutdown", "");
-	if (result == NULL)
-		PyErr_WriteUnraisable(threading);
-	else
-		Py_DECREF(result);
-	Py_DECREF(threading);
+    PyObject *result;
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *threading = PyMapping_GetItemString(tstate->interp->modules,
+                                                  "threading");
+    if (threading == NULL) {
+        /* threading not imported */
+        PyErr_Clear();
+        return;
+    }
+    result = PyObject_CallMethod(threading, "_shutdown", "");
+    if (result == NULL)
+        PyErr_WriteUnraisable(threading);
+    else
+        Py_DECREF(result);
+    Py_DECREF(threading);
 #endif
 }
 
@@ -1702,66 +1702,66 @@ static int nexitfuncs = 0;
 
 int Py_AtExit(void (*func)(void))
 {
-	if (nexitfuncs >= NEXITFUNCS)
-		return -1;
-	exitfuncs[nexitfuncs++] = func;
-	return 0;
+    if (nexitfuncs >= NEXITFUNCS)
+        return -1;
+    exitfuncs[nexitfuncs++] = func;
+    return 0;
 }
 
 static void
 call_sys_exitfunc(void)
 {
-	PyObject *exitfunc = PySys_GetObject("exitfunc");
+    PyObject *exitfunc = PySys_GetObject("exitfunc");
 
-	if (exitfunc) {
-		PyObject *res;
-		Py_INCREF(exitfunc);
-		PySys_SetObject("exitfunc", (PyObject *)NULL);
-		res = PyEval_CallObject(exitfunc, (PyObject *)NULL);
-		if (res == NULL) {
-			if (!PyErr_ExceptionMatches(PyExc_SystemExit)) {
-				PySys_WriteStderr("Error in sys.exitfunc:\n");
-			}
-			PyErr_Print();
-		}
-		Py_DECREF(exitfunc);
-	}
+    if (exitfunc) {
+        PyObject *res;
+        Py_INCREF(exitfunc);
+        PySys_SetObject("exitfunc", (PyObject *)NULL);
+        res = PyEval_CallObject(exitfunc, (PyObject *)NULL);
+        if (res == NULL) {
+            if (!PyErr_ExceptionMatches(PyExc_SystemExit)) {
+                PySys_WriteStderr("Error in sys.exitfunc:\n");
+            }
+            PyErr_Print();
+        }
+        Py_DECREF(exitfunc);
+    }
 
-	if (Py_FlushLine())
-		PyErr_Clear();
+    if (Py_FlushLine())
+        PyErr_Clear();
 }
 
 static void
 call_ll_exitfuncs(void)
 {
-	while (nexitfuncs > 0)
-		(*exitfuncs[--nexitfuncs])();
+    while (nexitfuncs > 0)
+        (*exitfuncs[--nexitfuncs])();
 
-	fflush(stdout);
-	fflush(stderr);
+    fflush(stdout);
+    fflush(stderr);
 }
 
 void
 Py_Exit(int sts)
 {
-	Py_Finalize();
+    Py_Finalize();
 
-	exit(sts);
+    exit(sts);
 }
 
 static void
 initsigs(void)
 {
 #ifdef SIGPIPE
-	PyOS_setsig(SIGPIPE, SIG_IGN);
+    PyOS_setsig(SIGPIPE, SIG_IGN);
 #endif
 #ifdef SIGXFZ
-	PyOS_setsig(SIGXFZ, SIG_IGN);
+    PyOS_setsig(SIGXFZ, SIG_IGN);
 #endif
 #ifdef SIGXFSZ
-	PyOS_setsig(SIGXFSZ, SIG_IGN);
+    PyOS_setsig(SIGXFSZ, SIG_IGN);
 #endif
-	PyOS_InitInterrupts(); /* May imply initsignal() */
+    PyOS_InitInterrupts(); /* May imply initsignal() */
 }
 
 
@@ -1774,13 +1774,13 @@ initsigs(void)
 int
 Py_FdIsInteractive(FILE *fp, const char *filename)
 {
-	if (isatty((int)fileno(fp)))
-		return 1;
-	if (!Py_InteractiveFlag)
-		return 0;
-	return (filename == NULL) ||
-	       (strcmp(filename, "<stdin>") == 0) ||
-	       (strcmp(filename, "???") == 0);
+    if (isatty((int)fileno(fp)))
+        return 1;
+    if (!Py_InteractiveFlag)
+        return 0;
+    return (filename == NULL) ||
+           (strcmp(filename, "<stdin>") == 0) ||
+           (strcmp(filename, "???") == 0);
 }
 
 
@@ -1798,21 +1798,21 @@ Py_FdIsInteractive(FILE *fp, const char *filename)
 int
 PyOS_CheckStack(void)
 {
-	__try {
-		/* alloca throws a stack overflow exception if there's
-		   not enough space left on the stack */
-		alloca(PYOS_STACK_MARGIN * sizeof(void*));
-		return 0;
-	} __except (GetExceptionCode() == STATUS_STACK_OVERFLOW ?
-		        EXCEPTION_EXECUTE_HANDLER :
-		        EXCEPTION_CONTINUE_SEARCH) {
-		int errcode = _resetstkoflw();
-		if (errcode == 0)
-		{
-			Py_FatalError("Could not reset the stack!");
-		}
-	}
-	return 1;
+    __try {
+        /* alloca throws a stack overflow exception if there's
+           not enough space left on the stack */
+        alloca(PYOS_STACK_MARGIN * sizeof(void*));
+        return 0;
+    } __except (GetExceptionCode() == STATUS_STACK_OVERFLOW ?
+                    EXCEPTION_EXECUTE_HANDLER :
+            EXCEPTION_CONTINUE_SEARCH) {
+        int errcode = _resetstkoflw();
+        if (errcode == 0)
+        {
+            Py_FatalError("Could not reset the stack!");
+        }
+    }
+    return 1;
 }
 
 #endif /* WIN32 && _MSC_VER */
@@ -1828,33 +1828,33 @@ PyOS_sighandler_t
 PyOS_getsig(int sig)
 {
 #ifdef HAVE_SIGACTION
-	struct sigaction context;
-	if (sigaction(sig, NULL, &context) == -1)
-		return SIG_ERR;
-	return context.sa_handler;
+    struct sigaction context;
+    if (sigaction(sig, NULL, &context) == -1)
+        return SIG_ERR;
+    return context.sa_handler;
 #else
-	PyOS_sighandler_t handler;
+    PyOS_sighandler_t handler;
 /* Special signal handling for the secure CRT in Visual Studio 2005 */
 #if defined(_MSC_VER) && _MSC_VER >= 1400
-	switch (sig) {
-	/* Only these signals are valid */
-	case SIGINT:
-	case SIGILL:
-	case SIGFPE:
-	case SIGSEGV:
-	case SIGTERM:
-	case SIGBREAK:
-	case SIGABRT:
-		break;
-	/* Don't call signal() with other values or it will assert */
-	default:
-		return SIG_ERR;
-	}
+    switch (sig) {
+    /* Only these signals are valid */
+    case SIGINT:
+    case SIGILL:
+    case SIGFPE:
+    case SIGSEGV:
+    case SIGTERM:
+    case SIGBREAK:
+    case SIGABRT:
+        break;
+    /* Don't call signal() with other values or it will assert */
+    default:
+        return SIG_ERR;
+    }
 #endif /* _MSC_VER && _MSC_VER >= 1400 */
-	handler = signal(sig, SIG_IGN);
-	if (handler != SIG_ERR)
-		signal(sig, handler);
-	return handler;
+    handler = signal(sig, SIG_IGN);
+    if (handler != SIG_ERR)
+        signal(sig, handler);
+    return handler;
 #endif
 }
 
@@ -1862,24 +1862,24 @@ PyOS_sighandler_t
 PyOS_setsig(int sig, PyOS_sighandler_t handler)
 {
 #ifdef HAVE_SIGACTION
-	/* Some code in Modules/signalmodule.c depends on sigaction() being
-	 * used here if HAVE_SIGACTION is defined.  Fix that if this code
-	 * changes to invalidate that assumption.
-	 */
-	struct sigaction context, ocontext;
-	context.sa_handler = handler;
-	sigemptyset(&context.sa_mask);
-	context.sa_flags = 0;
-	if (sigaction(sig, &context, &ocontext) == -1)
-		return SIG_ERR;
-	return ocontext.sa_handler;
+    /* Some code in Modules/signalmodule.c depends on sigaction() being
+     * used here if HAVE_SIGACTION is defined.  Fix that if this code
+     * changes to invalidate that assumption.
+     */
+    struct sigaction context, ocontext;
+    context.sa_handler = handler;
+    sigemptyset(&context.sa_mask);
+    context.sa_flags = 0;
+    if (sigaction(sig, &context, &ocontext) == -1)
+        return SIG_ERR;
+    return ocontext.sa_handler;
 #else
-	PyOS_sighandler_t oldhandler;
-	oldhandler = signal(sig, handler);
+    PyOS_sighandler_t oldhandler;
+    oldhandler = signal(sig, handler);
 #ifdef HAVE_SIGINTERRUPT
-	siginterrupt(sig, 1);
+    siginterrupt(sig, 1);
 #endif
-	return oldhandler;
+    return oldhandler;
 #endif
 }
 
@@ -1889,71 +1889,71 @@ PyOS_setsig(int sig, PyOS_sighandler_t handler)
 PyAPI_FUNC(node *)
 PyParser_SimpleParseFile(FILE *fp, const char *filename, int start)
 {
-	return PyParser_SimpleParseFileFlags(fp, filename, start, 0);
+    return PyParser_SimpleParseFileFlags(fp, filename, start, 0);
 }
 
 #undef PyParser_SimpleParseString
 PyAPI_FUNC(node *)
 PyParser_SimpleParseString(const char *str, int start)
 {
-	return PyParser_SimpleParseStringFlags(str, start, 0);
+    return PyParser_SimpleParseStringFlags(str, start, 0);
 }
 
 #undef PyRun_AnyFile
 PyAPI_FUNC(int)
 PyRun_AnyFile(FILE *fp, const char *name)
 {
-	return PyRun_AnyFileExFlags(fp, name, 0, NULL);
+    return PyRun_AnyFileExFlags(fp, name, 0, NULL);
 }
 
 #undef PyRun_AnyFileEx
 PyAPI_FUNC(int)
 PyRun_AnyFileEx(FILE *fp, const char *name, int closeit)
 {
-	return PyRun_AnyFileExFlags(fp, name, closeit, NULL);
+    return PyRun_AnyFileExFlags(fp, name, closeit, NULL);
 }
 
 #undef PyRun_AnyFileFlags
 PyAPI_FUNC(int)
 PyRun_AnyFileFlags(FILE *fp, const char *name, PyCompilerFlags *flags)
 {
-	return PyRun_AnyFileExFlags(fp, name, 0, flags);
+    return PyRun_AnyFileExFlags(fp, name, 0, flags);
 }
 
 #undef PyRun_File
 PyAPI_FUNC(PyObject *)
 PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l)
 {
-	return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL);
+    return PyRun_FileExFlags(fp, p, s, g, l, 0, NULL);
 }
 
 #undef PyRun_FileEx
 PyAPI_FUNC(PyObject *)
 PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c)
 {
-	return PyRun_FileExFlags(fp, p, s, g, l, c, NULL);
+    return PyRun_FileExFlags(fp, p, s, g, l, c, NULL);
 }
 
 #undef PyRun_FileFlags
 PyAPI_FUNC(PyObject *)
 PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l,
-		PyCompilerFlags *flags)
+                PyCompilerFlags *flags)
 {
-	return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
+    return PyRun_FileExFlags(fp, p, s, g, l, 0, flags);
 }
 
 #undef PyRun_SimpleFile
 PyAPI_FUNC(int)
 PyRun_SimpleFile(FILE *f, const char *p)
 {
-	return PyRun_SimpleFileExFlags(f, p, 0, NULL);
+    return PyRun_SimpleFileExFlags(f, p, 0, NULL);
 }
 
 #undef PyRun_SimpleFileEx
 PyAPI_FUNC(int)
 PyRun_SimpleFileEx(FILE *f, const char *p, int c)
 {
-	return PyRun_SimpleFileExFlags(f, p, c, NULL);
+    return PyRun_SimpleFileExFlags(f, p, c, NULL);
 }
 
 
@@ -1961,35 +1961,35 @@ PyRun_SimpleFileEx(FILE *f, const char *p, int c)
 PyAPI_FUNC(PyObject *)
 PyRun_String(const char *str, int s, PyObject *g, PyObject *l)
 {
-	return PyRun_StringFlags(str, s, g, l, NULL);
+    return PyRun_StringFlags(str, s, g, l, NULL);
 }
 
 #undef PyRun_SimpleString
 PyAPI_FUNC(int)
 PyRun_SimpleString(const char *s)
 {
-	return PyRun_SimpleStringFlags(s, NULL);
+    return PyRun_SimpleStringFlags(s, NULL);
 }
 
 #undef Py_CompileString
 PyAPI_FUNC(PyObject *)
 Py_CompileString(const char *str, const char *p, int s)
 {
-	return Py_CompileStringFlags(str, p, s, NULL);
+    return Py_CompileStringFlags(str, p, s, NULL);
 }
 
 #undef PyRun_InteractiveOne
 PyAPI_FUNC(int)
 PyRun_InteractiveOne(FILE *f, const char *p)
 {
-	return PyRun_InteractiveOneFlags(f, p, NULL);
+    return PyRun_InteractiveOneFlags(f, p, NULL);
 }
 
 #undef PyRun_InteractiveLoop
 PyAPI_FUNC(int)
 PyRun_InteractiveLoop(FILE *f, const char *p)
 {
-	return PyRun_InteractiveLoopFlags(f, p, NULL);
+    return PyRun_InteractiveLoopFlags(f, p, NULL);
 }
 
 #ifdef __cplusplus
diff --git a/Python/strtod.c b/Python/strtod.c
index 748f37b..ee55898 100644
--- a/Python/strtod.c
+++ b/Python/strtod.c
@@ -25,9 +25,9 @@
 
     There are two reasons why this should be provided to the net:
     (a) some UNIX systems do not yet have strtod(), or do not have it
-        available in the BSD "universe" (but they do have atof()).
+    available in the BSD "universe" (but they do have atof()).
     (b) some of the UNIX systems that *do* have it get it wrong.
-	(some crash with large arguments, some assign the wrong *ptr value).
+    (some crash with large arguments, some assign the wrong *ptr value).
     There is a reason why *we* are providing it: we need a correct version
     of strtod(), and if we give this one away maybe someone will look for
     mistakes in it and fix them for us (:-).
@@ -35,8 +35,8 @@
 
 /*  The following constants are machine-specific.  MD{MIN,MAX}EXPT are
     integers and MD{MIN,MAX}FRAC are strings such that
-	0.${MDMAXFRAC}e${MDMAXEXPT} is the largest representable double,
-	0.${MDMINFRAC}e${MDMINEXPT} is the smallest representable +ve double
+    0.${MDMAXFRAC}e${MDMAXEXPT} is the largest representable double,
+    0.${MDMINFRAC}e${MDMINEXPT} is the smallest representable +ve double
     MD{MIN,MAX}FRAC must not have any trailing zeros.
     The values here are for IEEE-754 64-bit floats.
     It is not perfectly clear to me whether an IEEE infinity should be
@@ -47,113 +47,113 @@
     I do know about <values.h>, but the whole point of this file is that
     we can't always trust that stuff to be there or to be correct.
 */
-static	int	MDMINEXPT	= -323;
-static	char	MDMINFRAC[]	= "494065645841246544";
-static	double	ZERO		= 0.0;
+static  int     MDMINEXPT       = -323;
+static  char    MDMINFRAC[]     = "494065645841246544";
+static  double  ZERO            = 0.0;
 
-static	int	MDMAXEXPT	= 309;
-static	char	MDMAXFRAC[]	= "17976931348623157";
-static	double	HUGE		= 1.7976931348623157e308;
+static  int     MDMAXEXPT       = 309;
+static  char    MDMAXFRAC[]     = "17976931348623157";
+static  double  HUGE            = 1.7976931348623157e308;
 
-extern	double	atof(const char *);		/* Only called when result known to be ok */
+extern  double  atof(const char *);             /* Only called when result known to be ok */
 
 #ifdef HAVE_ERRNO_H
 #include <errno.h>
 #endif
-extern	int	errno;
+extern  int     errno;
 
 double strtod(char *str, char **ptr)
 {
-	int sign, scale, dotseen;
-	int esign, expt;
-	char *save;
-	register char *sp, *dp;
-	register int c;
-	char *buforg, *buflim;
-	char buffer[64];		/* 45-digit significant + */
-					/* 13-digit exponent */
-	sp = str;
-	while (*sp == ' ') sp++;
-	sign = 1;
-	if (*sp == '-') sign -= 2, sp++;
-	dotseen = 0, scale = 0;
-	dp = buffer;
-	*dp++ = '0'; *dp++ = '.';
-	buforg = dp, buflim = buffer+48;
-	for (save = sp; (c = *sp); sp++)
-	    if (c == '.') {
-		if (dotseen) break;
-		dotseen++;
-	    } else
-	    if ((unsigned)(c-'0') > (unsigned)('9'-'0')) {
-		break;
-	    } else
-	    if (c == '0') {
-		if (dp != buforg) {
-		    /* This is not the first digit, so we want to keep it */
-		    if (dp < buflim) *dp++ = c;
-		    if (!dotseen) scale++;
-		} else {
-		    /* No non-zero digits seen yet */
-		    /* If a . has been seen, scale must be adjusted */
-		    if (dotseen) scale--;
-		}
-	    } else {
-		/* This is a nonzero digit, so we want to keep it */
-		if (dp < buflim) *dp++ = c;
-		/* If it precedes a ., scale must be adjusted */
-		if (!dotseen) scale++;
-	    }
-	if (sp == save) {
-	    if (ptr) *ptr = str;
-	    errno = EDOM;		/* what should this be? */
-	    return ZERO;
-	}
+    int sign, scale, dotseen;
+    int esign, expt;
+    char *save;
+    register char *sp, *dp;
+    register int c;
+    char *buforg, *buflim;
+    char buffer[64];                    /* 45-digit significant + */
+                    /* 13-digit exponent */
+    sp = str;
+    while (*sp == ' ') sp++;
+    sign = 1;
+    if (*sp == '-') sign -= 2, sp++;
+    dotseen = 0, scale = 0;
+    dp = buffer;
+    *dp++ = '0'; *dp++ = '.';
+    buforg = dp, buflim = buffer+48;
+    for (save = sp; (c = *sp); sp++)
+        if (c == '.') {
+        if (dotseen) break;
+        dotseen++;
+        } else
+        if ((unsigned)(c-'0') > (unsigned)('9'-'0')) {
+        break;
+        } else
+        if (c == '0') {
+        if (dp != buforg) {
+            /* This is not the first digit, so we want to keep it */
+            if (dp < buflim) *dp++ = c;
+            if (!dotseen) scale++;
+        } else {
+            /* No non-zero digits seen yet */
+            /* If a . has been seen, scale must be adjusted */
+            if (dotseen) scale--;
+        }
+        } else {
+        /* This is a nonzero digit, so we want to keep it */
+        if (dp < buflim) *dp++ = c;
+        /* If it precedes a ., scale must be adjusted */
+        if (!dotseen) scale++;
+        }
+    if (sp == save) {
+        if (ptr) *ptr = str;
+        errno = EDOM;                   /* what should this be? */
+        return ZERO;
+    }
 
-	while (dp > buforg && dp[-1] == '0') --dp;
-	if (dp == buforg) *dp++ = '0';
-	*dp = '\0';
-	/*  Now the contents of buffer are
-	    +--+--------+-+--------+
-	    |0.|fraction|\|leftover|
-	    +--+--------+-+--------+
-			 ^dp points here
-	    where fraction begins with 0 iff it is "0", and has at most
-	    45 digits in it, and leftover is at least 16 characters.
-	*/
-	save = sp, expt = 0, esign = 1;
-	do {
-	    c = *sp++;
-	    if (c != 'e' && c != 'E') break;
-	    c = *sp++;
-	    if (c == '-') esign -= 2, c = *sp++; else
-	    if (c == '+' /* || c == ' ' */ ) c = *sp++;
-	    if ((unsigned)(c-'0') > (unsigned)('9'-'0')) break;
-	    while (c == '0') c = *sp++;
-	    for (; (unsigned)(c-'0') <= (unsigned)('9'-'0'); c = *sp++)
-		expt = expt*10 + c-'0';
-	    if (esign < 0) expt = -expt;
-	    save = sp-1;
-	} while (0);
-	if (ptr) *ptr = save;
-	expt += scale;
-	/*  Now the number is sign*0.fraction*10**expt  */
-	errno = ERANGE;
-	if (expt > MDMAXEXPT) {
-	    return HUGE*sign;
-	} else
-	if (expt == MDMAXEXPT) {
-	    if (strcmp(buforg, MDMAXFRAC) > 0) return HUGE*sign;
-	} else
-	if (expt < MDMINEXPT) {
-	    return ZERO*sign;
-	} else
-	if (expt == MDMINEXPT) {
-	    if (strcmp(buforg, MDMINFRAC) < 0) return ZERO*sign;
-	}
-	/*  We have now established that the number can be  */
-	/*  represented without overflow or underflow  */
-	(void) sprintf(dp, "E%d", expt);
-	errno = 0;
-	return atof(buffer)*sign;
+    while (dp > buforg && dp[-1] == '0') --dp;
+    if (dp == buforg) *dp++ = '0';
+    *dp = '\0';
+    /*  Now the contents of buffer are
+        +--+--------+-+--------+
+        |0.|fraction|\|leftover|
+        +--+--------+-+--------+
+                     ^dp points here
+        where fraction begins with 0 iff it is "0", and has at most
+        45 digits in it, and leftover is at least 16 characters.
+    */
+    save = sp, expt = 0, esign = 1;
+    do {
+        c = *sp++;
+        if (c != 'e' && c != 'E') break;
+        c = *sp++;
+        if (c == '-') esign -= 2, c = *sp++; else
+        if (c == '+' /* || c == ' ' */ ) c = *sp++;
+        if ((unsigned)(c-'0') > (unsigned)('9'-'0')) break;
+        while (c == '0') c = *sp++;
+        for (; (unsigned)(c-'0') <= (unsigned)('9'-'0'); c = *sp++)
+        expt = expt*10 + c-'0';
+        if (esign < 0) expt = -expt;
+        save = sp-1;
+    } while (0);
+    if (ptr) *ptr = save;
+    expt += scale;
+    /*  Now the number is sign*0.fraction*10**expt  */
+    errno = ERANGE;
+    if (expt > MDMAXEXPT) {
+        return HUGE*sign;
+    } else
+    if (expt == MDMAXEXPT) {
+        if (strcmp(buforg, MDMAXFRAC) > 0) return HUGE*sign;
+    } else
+    if (expt < MDMINEXPT) {
+        return ZERO*sign;
+    } else
+    if (expt == MDMINEXPT) {
+        if (strcmp(buforg, MDMINFRAC) < 0) return ZERO*sign;
+    }
+    /*  We have now established that the number can be  */
+    /*  represented without overflow or underflow  */
+    (void) sprintf(dp, "E%d", expt);
+    errno = 0;
+    return atof(buffer)*sign;
 }
diff --git a/Python/structmember.c b/Python/structmember.c
index ac75bf0..e347b51 100644
--- a/Python/structmember.c
+++ b/Python/structmember.c
@@ -8,356 +8,356 @@
 static PyObject *
 listmembers(struct memberlist *mlist)
 {
-	int i, n;
-	PyObject *v;
-	for (n = 0; mlist[n].name != NULL; n++)
-		;
-	v = PyList_New(n);
-	if (v != NULL) {
-		for (i = 0; i < n; i++)
-			PyList_SetItem(v, i,
-				       PyString_FromString(mlist[i].name));
-		if (PyErr_Occurred()) {
-			Py_DECREF(v);
-			v = NULL;
-		}
-		else {
-			PyList_Sort(v);
-		}
-	}
-	return v;
+    int i, n;
+    PyObject *v;
+    for (n = 0; mlist[n].name != NULL; n++)
+        ;
+    v = PyList_New(n);
+    if (v != NULL) {
+        for (i = 0; i < n; i++)
+            PyList_SetItem(v, i,
+                           PyString_FromString(mlist[i].name));
+        if (PyErr_Occurred()) {
+            Py_DECREF(v);
+            v = NULL;
+        }
+        else {
+            PyList_Sort(v);
+        }
+    }
+    return v;
 }
 
 PyObject *
 PyMember_Get(const char *addr, struct memberlist *mlist, const char *name)
 {
-	struct memberlist *l;
+    struct memberlist *l;
 
-	if (strcmp(name, "__members__") == 0)
-		return listmembers(mlist);
-	for (l = mlist; l->name != NULL; l++) {
-		if (strcmp(l->name, name) == 0) {
-			PyMemberDef copy;
-			copy.name = l->name;
-			copy.type = l->type;
-			copy.offset = l->offset;
-			copy.flags = l->flags;
-			copy.doc = NULL;
-			return PyMember_GetOne(addr, &copy);
-		}
-	}
-	PyErr_SetString(PyExc_AttributeError, name);
-	return NULL;
+    if (strcmp(name, "__members__") == 0)
+        return listmembers(mlist);
+    for (l = mlist; l->name != NULL; l++) {
+        if (strcmp(l->name, name) == 0) {
+            PyMemberDef copy;
+            copy.name = l->name;
+            copy.type = l->type;
+            copy.offset = l->offset;
+            copy.flags = l->flags;
+            copy.doc = NULL;
+            return PyMember_GetOne(addr, &copy);
+        }
+    }
+    PyErr_SetString(PyExc_AttributeError, name);
+    return NULL;
 }
 
 PyObject *
 PyMember_GetOne(const char *addr, PyMemberDef *l)
 {
-	PyObject *v;
-	if ((l->flags & READ_RESTRICTED) &&
-	    PyEval_GetRestricted()) {
-		PyErr_SetString(PyExc_RuntimeError, "restricted attribute");
-		return NULL;
-	}
-	addr += l->offset;
-	switch (l->type) {
-	case T_BOOL:
-		v = PyBool_FromLong(*(char*)addr);
-		break;
-	case T_BYTE:
-		v = PyInt_FromLong(*(char*)addr);
-		break;
-	case T_UBYTE:
-		v = PyLong_FromUnsignedLong(*(unsigned char*)addr);
-		break;
-	case T_SHORT:
-		v = PyInt_FromLong(*(short*)addr);
-		break;
-	case T_USHORT:
-		v = PyLong_FromUnsignedLong(*(unsigned short*)addr);
-		break;
-	case T_INT:
-		v = PyInt_FromLong(*(int*)addr);
-		break;
-	case T_UINT:
-		v = PyLong_FromUnsignedLong(*(unsigned int*)addr);
-		break;
-	case T_LONG:
-		v = PyInt_FromLong(*(long*)addr);
-		break;
-	case T_ULONG:
-		v = PyLong_FromUnsignedLong(*(unsigned long*)addr);
-		break;
-	case T_PYSSIZET:
-		v = PyInt_FromSsize_t(*(Py_ssize_t*)addr);
-		break;
-	case T_FLOAT:
-		v = PyFloat_FromDouble((double)*(float*)addr);
-		break;
-	case T_DOUBLE:
-		v = PyFloat_FromDouble(*(double*)addr);
-		break;
-	case T_STRING:
-		if (*(char**)addr == NULL) {
-			Py_INCREF(Py_None);
-			v = Py_None;
-		}
-		else
-			v = PyString_FromString(*(char**)addr);
-		break;
-	case T_STRING_INPLACE:
-		v = PyString_FromString((char*)addr);
-		break;
-	case T_CHAR:
-		v = PyString_FromStringAndSize((char*)addr, 1);
-		break;
-	case T_OBJECT:
-		v = *(PyObject **)addr;
-		if (v == NULL)
-			v = Py_None;
-		Py_INCREF(v);
-		break;
-	case T_OBJECT_EX:
-		v = *(PyObject **)addr;
-		if (v == NULL)
-			PyErr_SetString(PyExc_AttributeError, l->name);
-		Py_XINCREF(v);
-		break;
+    PyObject *v;
+    if ((l->flags & READ_RESTRICTED) &&
+        PyEval_GetRestricted()) {
+        PyErr_SetString(PyExc_RuntimeError, "restricted attribute");
+        return NULL;
+    }
+    addr += l->offset;
+    switch (l->type) {
+    case T_BOOL:
+        v = PyBool_FromLong(*(char*)addr);
+        break;
+    case T_BYTE:
+        v = PyInt_FromLong(*(char*)addr);
+        break;
+    case T_UBYTE:
+        v = PyLong_FromUnsignedLong(*(unsigned char*)addr);
+        break;
+    case T_SHORT:
+        v = PyInt_FromLong(*(short*)addr);
+        break;
+    case T_USHORT:
+        v = PyLong_FromUnsignedLong(*(unsigned short*)addr);
+        break;
+    case T_INT:
+        v = PyInt_FromLong(*(int*)addr);
+        break;
+    case T_UINT:
+        v = PyLong_FromUnsignedLong(*(unsigned int*)addr);
+        break;
+    case T_LONG:
+        v = PyInt_FromLong(*(long*)addr);
+        break;
+    case T_ULONG:
+        v = PyLong_FromUnsignedLong(*(unsigned long*)addr);
+        break;
+    case T_PYSSIZET:
+        v = PyInt_FromSsize_t(*(Py_ssize_t*)addr);
+        break;
+    case T_FLOAT:
+        v = PyFloat_FromDouble((double)*(float*)addr);
+        break;
+    case T_DOUBLE:
+        v = PyFloat_FromDouble(*(double*)addr);
+        break;
+    case T_STRING:
+        if (*(char**)addr == NULL) {
+            Py_INCREF(Py_None);
+            v = Py_None;
+        }
+        else
+            v = PyString_FromString(*(char**)addr);
+        break;
+    case T_STRING_INPLACE:
+        v = PyString_FromString((char*)addr);
+        break;
+    case T_CHAR:
+        v = PyString_FromStringAndSize((char*)addr, 1);
+        break;
+    case T_OBJECT:
+        v = *(PyObject **)addr;
+        if (v == NULL)
+            v = Py_None;
+        Py_INCREF(v);
+        break;
+    case T_OBJECT_EX:
+        v = *(PyObject **)addr;
+        if (v == NULL)
+            PyErr_SetString(PyExc_AttributeError, l->name);
+        Py_XINCREF(v);
+        break;
 #ifdef HAVE_LONG_LONG
-	case T_LONGLONG:
-		v = PyLong_FromLongLong(*(PY_LONG_LONG *)addr);
-		break;
-	case T_ULONGLONG:
-		v = PyLong_FromUnsignedLongLong(*(unsigned PY_LONG_LONG *)addr);
-		break;
+    case T_LONGLONG:
+        v = PyLong_FromLongLong(*(PY_LONG_LONG *)addr);
+        break;
+    case T_ULONGLONG:
+        v = PyLong_FromUnsignedLongLong(*(unsigned PY_LONG_LONG *)addr);
+        break;
 #endif /* HAVE_LONG_LONG */
-	default:
-		PyErr_SetString(PyExc_SystemError, "bad memberdescr type");
-		v = NULL;
-	}
-	return v;
+    default:
+        PyErr_SetString(PyExc_SystemError, "bad memberdescr type");
+        v = NULL;
+    }
+    return v;
 }
 
 int
 PyMember_Set(char *addr, struct memberlist *mlist, const char *name, PyObject *v)
 {
-	struct memberlist *l;
+    struct memberlist *l;
 
-	for (l = mlist; l->name != NULL; l++) {
-		if (strcmp(l->name, name) == 0) {
-			PyMemberDef copy;
-			copy.name = l->name;
-			copy.type = l->type;
-			copy.offset = l->offset;
-			copy.flags = l->flags;
-			copy.doc = NULL;
-			return PyMember_SetOne(addr, &copy, v);
-		}
-	}
+    for (l = mlist; l->name != NULL; l++) {
+        if (strcmp(l->name, name) == 0) {
+            PyMemberDef copy;
+            copy.name = l->name;
+            copy.type = l->type;
+            copy.offset = l->offset;
+            copy.flags = l->flags;
+            copy.doc = NULL;
+            return PyMember_SetOne(addr, &copy, v);
+        }
+    }
 
-	PyErr_SetString(PyExc_AttributeError, name);
-	return -1;
+    PyErr_SetString(PyExc_AttributeError, name);
+    return -1;
 }
 
-#define WARN(msg)					\
-    do {						\
-	if (PyErr_Warn(PyExc_RuntimeWarning, msg) < 0)	\
-		return -1;				\
+#define WARN(msg)                                       \
+    do {                                                \
+    if (PyErr_Warn(PyExc_RuntimeWarning, msg) < 0)      \
+        return -1;                                      \
     } while (0)
 
 int
 PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v)
 {
-	PyObject *oldv;
+    PyObject *oldv;
 
-	addr += l->offset;
+    addr += l->offset;
 
-	if ((l->flags & READONLY))
-	{
-		PyErr_SetString(PyExc_TypeError, "readonly attribute");
-		return -1;
-	}
-	if ((l->flags & PY_WRITE_RESTRICTED) && PyEval_GetRestricted()) {
-		PyErr_SetString(PyExc_RuntimeError, "restricted attribute");
-		return -1;
-	}
-	if (v == NULL) {
-		if (l->type == T_OBJECT_EX) {
-			/* Check if the attribute is set. */
-			if (*(PyObject **)addr == NULL) {
-				PyErr_SetString(PyExc_AttributeError, l->name);
-				return -1;
-			}
-		}
-		else if (l->type != T_OBJECT) {
-			PyErr_SetString(PyExc_TypeError,
-					"can't delete numeric/char attribute");
-			return -1;
-		}
-	}
-	switch (l->type) {
-	case T_BOOL:{
-		if (!PyBool_Check(v)) {
-			PyErr_SetString(PyExc_TypeError,
-					"attribute value type must be bool");
-			return -1;
-		}
-		if (v == Py_True)
-			*(char*)addr = (char) 1;
-		else
-			*(char*)addr = (char) 0;
-		break;
-		}
-	case T_BYTE:{
-		long long_val = PyInt_AsLong(v);
-		if ((long_val == -1) && PyErr_Occurred())
-			return -1;
-		*(char*)addr = (char)long_val;
-		/* XXX: For compatibility, only warn about truncations
-		   for now. */
-		if ((long_val > CHAR_MAX) || (long_val < CHAR_MIN))
-			WARN("Truncation of value to char");
-		break;
-		}
-	case T_UBYTE:{
-		long long_val = PyInt_AsLong(v);
-		if ((long_val == -1) && PyErr_Occurred())
-			return -1;
-		*(unsigned char*)addr = (unsigned char)long_val;
-		if ((long_val > UCHAR_MAX) || (long_val < 0))
-			WARN("Truncation of value to unsigned char");
-		break;
-		}
-	case T_SHORT:{
-		long long_val = PyInt_AsLong(v);
-		if ((long_val == -1) && PyErr_Occurred())
-			return -1;
-		*(short*)addr = (short)long_val;
-		if ((long_val > SHRT_MAX) || (long_val < SHRT_MIN))
-			WARN("Truncation of value to short");
-		break;
-		}
-	case T_USHORT:{
-		long long_val = PyInt_AsLong(v);
-		if ((long_val == -1) && PyErr_Occurred())
-			return -1;
-		*(unsigned short*)addr = (unsigned short)long_val;
-		if ((long_val > USHRT_MAX) || (long_val < 0))
-			WARN("Truncation of value to unsigned short");
-		break;
-		}
-  	case T_INT:{
-		long long_val = PyInt_AsLong(v);
-		if ((long_val == -1) && PyErr_Occurred())
-			return -1;
-		*(int *)addr = (int)long_val;
-		if ((long_val > INT_MAX) || (long_val < INT_MIN))
-			WARN("Truncation of value to int");
-		break;
-		}
-	case T_UINT:{
-		unsigned long ulong_val = PyLong_AsUnsignedLong(v);
-		if ((ulong_val == (unsigned long)-1) && PyErr_Occurred()) {
-			/* XXX: For compatibility, accept negative int values
-			   as well. */
-			PyErr_Clear();
-			ulong_val = PyLong_AsLong(v);
-			if ((ulong_val == (unsigned long)-1) &&
-			    PyErr_Occurred())
-				return -1;
-			*(unsigned int *)addr = (unsigned int)ulong_val;
-			WARN("Writing negative value into unsigned field");
-		} else
-			*(unsigned int *)addr = (unsigned int)ulong_val;
-		if (ulong_val > UINT_MAX)
-			WARN("Truncation of value to unsigned int");
-		break;
-		}
-	case T_LONG:{
-		*(long*)addr = PyLong_AsLong(v);
-		if ((*(long*)addr == -1) && PyErr_Occurred())
-			return -1;
-		break;
-		}
-	case T_ULONG:{
-		*(unsigned long*)addr = PyLong_AsUnsignedLong(v);
-		if ((*(unsigned long*)addr == (unsigned long)-1)
-		    && PyErr_Occurred()) {
-			/* XXX: For compatibility, accept negative int values
-			   as well. */
-			PyErr_Clear();
-			*(unsigned long*)addr = PyLong_AsLong(v);
-			if ((*(unsigned long*)addr == (unsigned long)-1)
-			    && PyErr_Occurred())
-				return -1;
-			WARN("Writing negative value into unsigned field");
-		}
-		break;
-		}
-	case T_PYSSIZET:{
-		*(Py_ssize_t*)addr = PyInt_AsSsize_t(v);
-		if ((*(Py_ssize_t*)addr == (Py_ssize_t)-1)
-		    && PyErr_Occurred())
-				return -1;
-		break;
-		}
-	case T_FLOAT:{
-		double double_val = PyFloat_AsDouble(v);
-		if ((double_val == -1) && PyErr_Occurred())
-			return -1;
-		*(float*)addr = (float)double_val;
-		break;
-		}
-	case T_DOUBLE:
-		*(double*)addr = PyFloat_AsDouble(v);
-		if ((*(double*)addr == -1) && PyErr_Occurred())
-			return -1;
-		break;
-	case T_OBJECT:
-	case T_OBJECT_EX:
-		Py_XINCREF(v);
-		oldv = *(PyObject **)addr;
-		*(PyObject **)addr = v;
-		Py_XDECREF(oldv);
-		break;
-	case T_CHAR:
-		if (PyString_Check(v) && PyString_Size(v) == 1) {
-			*(char*)addr = PyString_AsString(v)[0];
-		}
-		else {
-			PyErr_BadArgument();
-			return -1;
-		}
-		break;
-	case T_STRING:
-	case T_STRING_INPLACE:
-		PyErr_SetString(PyExc_TypeError, "readonly attribute");
-		return -1;
+    if ((l->flags & READONLY))
+    {
+        PyErr_SetString(PyExc_TypeError, "readonly attribute");
+        return -1;
+    }
+    if ((l->flags & PY_WRITE_RESTRICTED) && PyEval_GetRestricted()) {
+        PyErr_SetString(PyExc_RuntimeError, "restricted attribute");
+        return -1;
+    }
+    if (v == NULL) {
+        if (l->type == T_OBJECT_EX) {
+            /* Check if the attribute is set. */
+            if (*(PyObject **)addr == NULL) {
+                PyErr_SetString(PyExc_AttributeError, l->name);
+                return -1;
+            }
+        }
+        else if (l->type != T_OBJECT) {
+            PyErr_SetString(PyExc_TypeError,
+                            "can't delete numeric/char attribute");
+            return -1;
+        }
+    }
+    switch (l->type) {
+    case T_BOOL:{
+        if (!PyBool_Check(v)) {
+            PyErr_SetString(PyExc_TypeError,
+                            "attribute value type must be bool");
+            return -1;
+        }
+        if (v == Py_True)
+            *(char*)addr = (char) 1;
+        else
+            *(char*)addr = (char) 0;
+        break;
+        }
+    case T_BYTE:{
+        long long_val = PyInt_AsLong(v);
+        if ((long_val == -1) && PyErr_Occurred())
+            return -1;
+        *(char*)addr = (char)long_val;
+        /* XXX: For compatibility, only warn about truncations
+           for now. */
+        if ((long_val > CHAR_MAX) || (long_val < CHAR_MIN))
+            WARN("Truncation of value to char");
+        break;
+        }
+    case T_UBYTE:{
+        long long_val = PyInt_AsLong(v);
+        if ((long_val == -1) && PyErr_Occurred())
+            return -1;
+        *(unsigned char*)addr = (unsigned char)long_val;
+        if ((long_val > UCHAR_MAX) || (long_val < 0))
+            WARN("Truncation of value to unsigned char");
+        break;
+        }
+    case T_SHORT:{
+        long long_val = PyInt_AsLong(v);
+        if ((long_val == -1) && PyErr_Occurred())
+            return -1;
+        *(short*)addr = (short)long_val;
+        if ((long_val > SHRT_MAX) || (long_val < SHRT_MIN))
+            WARN("Truncation of value to short");
+        break;
+        }
+    case T_USHORT:{
+        long long_val = PyInt_AsLong(v);
+        if ((long_val == -1) && PyErr_Occurred())
+            return -1;
+        *(unsigned short*)addr = (unsigned short)long_val;
+        if ((long_val > USHRT_MAX) || (long_val < 0))
+            WARN("Truncation of value to unsigned short");
+        break;
+        }
+    case T_INT:{
+        long long_val = PyInt_AsLong(v);
+        if ((long_val == -1) && PyErr_Occurred())
+            return -1;
+        *(int *)addr = (int)long_val;
+        if ((long_val > INT_MAX) || (long_val < INT_MIN))
+            WARN("Truncation of value to int");
+        break;
+        }
+    case T_UINT:{
+        unsigned long ulong_val = PyLong_AsUnsignedLong(v);
+        if ((ulong_val == (unsigned long)-1) && PyErr_Occurred()) {
+            /* XXX: For compatibility, accept negative int values
+               as well. */
+            PyErr_Clear();
+            ulong_val = PyLong_AsLong(v);
+            if ((ulong_val == (unsigned long)-1) &&
+                PyErr_Occurred())
+                return -1;
+            *(unsigned int *)addr = (unsigned int)ulong_val;
+            WARN("Writing negative value into unsigned field");
+        } else
+            *(unsigned int *)addr = (unsigned int)ulong_val;
+        if (ulong_val > UINT_MAX)
+            WARN("Truncation of value to unsigned int");
+        break;
+        }
+    case T_LONG:{
+        *(long*)addr = PyLong_AsLong(v);
+        if ((*(long*)addr == -1) && PyErr_Occurred())
+            return -1;
+        break;
+        }
+    case T_ULONG:{
+        *(unsigned long*)addr = PyLong_AsUnsignedLong(v);
+        if ((*(unsigned long*)addr == (unsigned long)-1)
+            && PyErr_Occurred()) {
+            /* XXX: For compatibility, accept negative int values
+               as well. */
+            PyErr_Clear();
+            *(unsigned long*)addr = PyLong_AsLong(v);
+            if ((*(unsigned long*)addr == (unsigned long)-1)
+                && PyErr_Occurred())
+                return -1;
+            WARN("Writing negative value into unsigned field");
+        }
+        break;
+        }
+    case T_PYSSIZET:{
+        *(Py_ssize_t*)addr = PyInt_AsSsize_t(v);
+        if ((*(Py_ssize_t*)addr == (Py_ssize_t)-1)
+            && PyErr_Occurred())
+                        return -1;
+        break;
+        }
+    case T_FLOAT:{
+        double double_val = PyFloat_AsDouble(v);
+        if ((double_val == -1) && PyErr_Occurred())
+            return -1;
+        *(float*)addr = (float)double_val;
+        break;
+        }
+    case T_DOUBLE:
+        *(double*)addr = PyFloat_AsDouble(v);
+        if ((*(double*)addr == -1) && PyErr_Occurred())
+            return -1;
+        break;
+    case T_OBJECT:
+    case T_OBJECT_EX:
+        Py_XINCREF(v);
+        oldv = *(PyObject **)addr;
+        *(PyObject **)addr = v;
+        Py_XDECREF(oldv);
+        break;
+    case T_CHAR:
+        if (PyString_Check(v) && PyString_Size(v) == 1) {
+            *(char*)addr = PyString_AsString(v)[0];
+        }
+        else {
+            PyErr_BadArgument();
+            return -1;
+        }
+        break;
+    case T_STRING:
+    case T_STRING_INPLACE:
+        PyErr_SetString(PyExc_TypeError, "readonly attribute");
+        return -1;
 #ifdef HAVE_LONG_LONG
-	case T_LONGLONG:{
-		PY_LONG_LONG value;
-		*(PY_LONG_LONG*)addr = value = PyLong_AsLongLong(v);
-		if ((value == -1) && PyErr_Occurred())
-			return -1;
-		break;
-		}
-	case T_ULONGLONG:{
-		unsigned PY_LONG_LONG value;
-		/* ??? PyLong_AsLongLong accepts an int, but PyLong_AsUnsignedLongLong
-			doesn't ??? */
-		if (PyLong_Check(v))
-			*(unsigned PY_LONG_LONG*)addr = value = PyLong_AsUnsignedLongLong(v);
-		else
-			*(unsigned PY_LONG_LONG*)addr = value = PyInt_AsLong(v);
-		if ((value == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())
-			return -1;
-		break;
-		}
+    case T_LONGLONG:{
+        PY_LONG_LONG value;
+        *(PY_LONG_LONG*)addr = value = PyLong_AsLongLong(v);
+        if ((value == -1) && PyErr_Occurred())
+            return -1;
+        break;
+        }
+    case T_ULONGLONG:{
+        unsigned PY_LONG_LONG value;
+        /* ??? PyLong_AsLongLong accepts an int, but PyLong_AsUnsignedLongLong
+            doesn't ??? */
+        if (PyLong_Check(v))
+            *(unsigned PY_LONG_LONG*)addr = value = PyLong_AsUnsignedLongLong(v);
+        else
+            *(unsigned PY_LONG_LONG*)addr = value = PyInt_AsLong(v);
+        if ((value == (unsigned PY_LONG_LONG)-1) && PyErr_Occurred())
+            return -1;
+        break;
+        }
 #endif /* HAVE_LONG_LONG */
-	default:
-		PyErr_Format(PyExc_SystemError,
-			     "bad memberdescr type for %s", l->name);
-		return -1;
-	}
-	return 0;
+    default:
+        PyErr_Format(PyExc_SystemError,
+                     "bad memberdescr type for %s", l->name);
+        return -1;
+    }
+    return 0;
 }
diff --git a/Python/symtable.c b/Python/symtable.c
index 0c463a2..0da2faf 100644
--- a/Python/symtable.c
+++ b/Python/symtable.c
@@ -19,149 +19,149 @@
 
 static PySTEntryObject *
 ste_new(struct symtable *st, identifier name, _Py_block_ty block,
-	      void *key, int lineno)
+              void *key, int lineno)
 {
-	PySTEntryObject *ste = NULL;
-	PyObject *k;
-
-	k = PyLong_FromVoidPtr(key);
-	if (k == NULL)
-		goto fail;
-	ste = PyObject_New(PySTEntryObject, &PySTEntry_Type);
-	if (ste == NULL)
-		goto fail;
-	ste->ste_table = st;
-	ste->ste_id = k;
-
-	ste->ste_name = name;
-	Py_INCREF(name);
-
-	ste->ste_symbols = NULL;
-	ste->ste_varnames = NULL;
-	ste->ste_children = NULL;
-
-	ste->ste_symbols = PyDict_New();
-	if (ste->ste_symbols == NULL)
-	    goto fail;
-
-	ste->ste_varnames = PyList_New(0);
-	if (ste->ste_varnames == NULL)
-	    goto fail;
-
-	ste->ste_children = PyList_New(0);
-	if (ste->ste_children == NULL)
-	    goto fail;
-
-	ste->ste_type = block;
-	ste->ste_unoptimized = 0;
-	ste->ste_nested = 0;
-	ste->ste_free = 0;
-	ste->ste_varargs = 0;
-	ste->ste_varkeywords = 0;
-	ste->ste_opt_lineno = 0;
-	ste->ste_lineno = lineno;
-
-	if (st->st_cur != NULL &&
-	    (st->st_cur->ste_nested ||
-	     st->st_cur->ste_type == FunctionBlock))
-		ste->ste_nested = 1;
-	ste->ste_child_free = 0;
-	ste->ste_generator = 0;
-	ste->ste_returns_value = 0;
-
-	if (PyDict_SetItem(st->st_symbols, ste->ste_id, (PyObject *)ste) < 0)
-	    goto fail;
-	
-	return ste;
+    PySTEntryObject *ste = NULL;
+    PyObject *k;
+
+    k = PyLong_FromVoidPtr(key);
+    if (k == NULL)
+        goto fail;
+    ste = PyObject_New(PySTEntryObject, &PySTEntry_Type);
+    if (ste == NULL)
+        goto fail;
+    ste->ste_table = st;
+    ste->ste_id = k;
+
+    ste->ste_name = name;
+    Py_INCREF(name);
+
+    ste->ste_symbols = NULL;
+    ste->ste_varnames = NULL;
+    ste->ste_children = NULL;
+
+    ste->ste_symbols = PyDict_New();
+    if (ste->ste_symbols == NULL)
+        goto fail;
+
+    ste->ste_varnames = PyList_New(0);
+    if (ste->ste_varnames == NULL)
+        goto fail;
+
+    ste->ste_children = PyList_New(0);
+    if (ste->ste_children == NULL)
+        goto fail;
+
+    ste->ste_type = block;
+    ste->ste_unoptimized = 0;
+    ste->ste_nested = 0;
+    ste->ste_free = 0;
+    ste->ste_varargs = 0;
+    ste->ste_varkeywords = 0;
+    ste->ste_opt_lineno = 0;
+    ste->ste_lineno = lineno;
+
+    if (st->st_cur != NULL &&
+        (st->st_cur->ste_nested ||
+         st->st_cur->ste_type == FunctionBlock))
+        ste->ste_nested = 1;
+    ste->ste_child_free = 0;
+    ste->ste_generator = 0;
+    ste->ste_returns_value = 0;
+
+    if (PyDict_SetItem(st->st_symbols, ste->ste_id, (PyObject *)ste) < 0)
+        goto fail;
+
+    return ste;
  fail:
-	Py_XDECREF(ste);
-	return NULL;
+    Py_XDECREF(ste);
+    return NULL;
 }
 
 static PyObject *
 ste_repr(PySTEntryObject *ste)
 {
-	char buf[256];
+    char buf[256];
 
-	PyOS_snprintf(buf, sizeof(buf),
-		      "<symtable entry %.100s(%ld), line %d>",
-		      PyString_AS_STRING(ste->ste_name),
-		      PyInt_AS_LONG(ste->ste_id), ste->ste_lineno);
-	return PyString_FromString(buf);
+    PyOS_snprintf(buf, sizeof(buf),
+                  "<symtable entry %.100s(%ld), line %d>",
+                  PyString_AS_STRING(ste->ste_name),
+                  PyInt_AS_LONG(ste->ste_id), ste->ste_lineno);
+    return PyString_FromString(buf);
 }
 
 static void
 ste_dealloc(PySTEntryObject *ste)
 {
-	ste->ste_table = NULL;
-	Py_XDECREF(ste->ste_id);
-	Py_XDECREF(ste->ste_name);
-	Py_XDECREF(ste->ste_symbols);
-	Py_XDECREF(ste->ste_varnames);
-	Py_XDECREF(ste->ste_children);
-	PyObject_Del(ste);
+    ste->ste_table = NULL;
+    Py_XDECREF(ste->ste_id);
+    Py_XDECREF(ste->ste_name);
+    Py_XDECREF(ste->ste_symbols);
+    Py_XDECREF(ste->ste_varnames);
+    Py_XDECREF(ste->ste_children);
+    PyObject_Del(ste);
 }
 
 #define OFF(x) offsetof(PySTEntryObject, x)
 
 static PyMemberDef ste_memberlist[] = {
-	{"id",       T_OBJECT, OFF(ste_id), READONLY},
-	{"name",     T_OBJECT, OFF(ste_name), READONLY},
-	{"symbols",  T_OBJECT, OFF(ste_symbols), READONLY},
-	{"varnames", T_OBJECT, OFF(ste_varnames), READONLY},
-	{"children", T_OBJECT, OFF(ste_children), READONLY},
-        {"optimized",T_INT,    OFF(ste_unoptimized), READONLY},
-	{"nested",   T_INT,    OFF(ste_nested), READONLY},
-	{"type",     T_INT,    OFF(ste_type), READONLY},
-	{"lineno",   T_INT,    OFF(ste_lineno), READONLY},
-	{NULL}
+    {"id",       T_OBJECT, OFF(ste_id), READONLY},
+    {"name",     T_OBJECT, OFF(ste_name), READONLY},
+    {"symbols",  T_OBJECT, OFF(ste_symbols), READONLY},
+    {"varnames", T_OBJECT, OFF(ste_varnames), READONLY},
+    {"children", T_OBJECT, OFF(ste_children), READONLY},
+    {"optimized",T_INT,    OFF(ste_unoptimized), READONLY},
+    {"nested",   T_INT,    OFF(ste_nested), READONLY},
+    {"type",     T_INT,    OFF(ste_type), READONLY},
+    {"lineno",   T_INT,    OFF(ste_lineno), READONLY},
+    {NULL}
 };
 
 PyTypeObject PySTEntry_Type = {
-	PyVarObject_HEAD_INIT(&PyType_Type, 0)
-	"symtable entry",
-	sizeof(PySTEntryObject),
-	0,
-	(destructor)ste_dealloc,                /* tp_dealloc */
-	0,                                      /* tp_print */
-	0,			               /* tp_getattr */
-	0,					/* tp_setattr */
-	0,			                /* tp_compare */
-	(reprfunc)ste_repr,			/* tp_repr */
-	0,					/* tp_as_number */
-	0,			                /* tp_as_sequence */
-	0,					/* tp_as_mapping */
-	0,					/* tp_hash */
-	0,					/* tp_call */
-	0,					/* tp_str */
-	PyObject_GenericGetAttr,		/* tp_getattro */
-	0,					/* tp_setattro */
-	0,					/* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT,	                /* tp_flags */
- 	0,					/* tp_doc */
-	0,					/* tp_traverse */
-	0,					/* tp_clear */
-	0,					/* tp_richcompare */
-	0,					/* tp_weaklistoffset */
-	0,					/* tp_iter */
-	0,					/* tp_iternext */
-	0,					/* tp_methods */
-	ste_memberlist,				/* tp_members */
-	0,					/* tp_getset */
-	0,					/* tp_base */
-	0,					/* tp_dict */
-	0,					/* tp_descr_get */
-	0,					/* tp_descr_set */
-	0,					/* tp_dictoffset */
-	0,					/* tp_init */
-	0,					/* tp_alloc */
-	0,					/* tp_new */
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
+    "symtable entry",
+    sizeof(PySTEntryObject),
+    0,
+    (destructor)ste_dealloc,                /* tp_dealloc */
+    0,                                      /* tp_print */
+    0,                                         /* tp_getattr */
+    0,                                          /* tp_setattr */
+    0,                                          /* tp_compare */
+    (reprfunc)ste_repr,                         /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    PyObject_GenericGetAttr,                    /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                         /* tp_flags */
+    0,                                          /* tp_doc */
+    0,                                          /* tp_traverse */
+    0,                                          /* tp_clear */
+    0,                                          /* tp_richcompare */
+    0,                                          /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    0,                                          /* tp_methods */
+    ste_memberlist,                             /* tp_members */
+    0,                                          /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    0,                                          /* tp_descr_get */
+    0,                                          /* tp_descr_set */
+    0,                                          /* tp_dictoffset */
+    0,                                          /* tp_init */
+    0,                                          /* tp_alloc */
+    0,                                          /* tp_new */
 };
 
 static int symtable_analyze(struct symtable *st);
 static int symtable_warn(struct symtable *st, char *msg, int lineno);
-static int symtable_enter_block(struct symtable *st, identifier name, 
-				_Py_block_ty block, void *ast, int lineno);
+static int symtable_enter_block(struct symtable *st, identifier name,
+                                _Py_block_ty block, void *ast, int lineno);
 static int symtable_exit_block(struct symtable *st, void *ast);
 static int symtable_visit_stmt(struct symtable *st, stmt_ty s);
 static int symtable_visit_expr(struct symtable *st, expr_ty s);
@@ -180,10 +180,10 @@ static int symtable_implicit_arg(struct symtable *st, int pos);
 
 
 static identifier top = NULL, lambda = NULL, genexpr = NULL, setcomp = NULL,
-	dictcomp = NULL;
+    dictcomp = NULL;
 
 #define GET_IDENTIFIER(VAR) \
-	((VAR) ? (VAR) : ((VAR) = PyString_InternFromString(# VAR)))
+    ((VAR) ? (VAR) : ((VAR) = PyString_InternFromString(# VAR)))
 
 #define DUPLICATE_ARGUMENT \
 "duplicate argument '%s' in function definition"
@@ -191,134 +191,134 @@ static identifier top = NULL, lambda = NULL, genexpr = NULL, setcomp = NULL,
 static struct symtable *
 symtable_new(void)
 {
-	struct symtable *st;
-
-	st = (struct symtable *)PyMem_Malloc(sizeof(struct symtable));
-	if (st == NULL)
-		return NULL;
-
-	st->st_filename = NULL;
-	st->st_symbols = NULL;
-
-	if ((st->st_stack = PyList_New(0)) == NULL)
-		goto fail;
-	if ((st->st_symbols = PyDict_New()) == NULL)
-		goto fail; 
-	st->st_cur = NULL;
-	st->st_private = NULL;
-	return st;
+    struct symtable *st;
+
+    st = (struct symtable *)PyMem_Malloc(sizeof(struct symtable));
+    if (st == NULL)
+        return NULL;
+
+    st->st_filename = NULL;
+    st->st_symbols = NULL;
+
+    if ((st->st_stack = PyList_New(0)) == NULL)
+        goto fail;
+    if ((st->st_symbols = PyDict_New()) == NULL)
+        goto fail;
+    st->st_cur = NULL;
+    st->st_private = NULL;
+    return st;
  fail:
-	PySymtable_Free(st);
-	return NULL;
+    PySymtable_Free(st);
+    return NULL;
 }
 
 struct symtable *
 PySymtable_Build(mod_ty mod, const char *filename, PyFutureFeatures *future)
 {
-	struct symtable *st = symtable_new();
-	asdl_seq *seq;
-	int i;
-
-	if (st == NULL)
-		return st;
-	st->st_filename = filename;
-	st->st_future = future;
-	if (!GET_IDENTIFIER(top) ||
-	    !symtable_enter_block(st, top, ModuleBlock, (void *)mod, 0)) {
-		PySymtable_Free(st);
-		return NULL;
-	}
-
-	st->st_top = st->st_cur;
-	st->st_cur->ste_unoptimized = OPT_TOPLEVEL;
-	/* Any other top-level initialization? */
-	switch (mod->kind) {
-	case Module_kind:
-		seq = mod->v.Module.body;
-		for (i = 0; i < asdl_seq_LEN(seq); i++)
-			if (!symtable_visit_stmt(st, 
-                                    (stmt_ty)asdl_seq_GET(seq, i)))
-				goto error;
-		break;
-	case Expression_kind:
-		if (!symtable_visit_expr(st, mod->v.Expression.body))
-			goto error;
-		break;
-	case Interactive_kind:
-		seq = mod->v.Interactive.body;
-		for (i = 0; i < asdl_seq_LEN(seq); i++)
-			if (!symtable_visit_stmt(st, 
-                                    (stmt_ty)asdl_seq_GET(seq, i)))
-				goto error;
-		break;
-	case Suite_kind:
-		PyErr_SetString(PyExc_RuntimeError,
-				"this compiler does not handle Suites");
-		goto error;
-	}
-	if (!symtable_exit_block(st, (void *)mod)) {
-		PySymtable_Free(st);
-		return NULL;
-	}
-	if (symtable_analyze(st))
-		return st;
-	PySymtable_Free(st);
-	return NULL;
+    struct symtable *st = symtable_new();
+    asdl_seq *seq;
+    int i;
+
+    if (st == NULL)
+        return st;
+    st->st_filename = filename;
+    st->st_future = future;
+    if (!GET_IDENTIFIER(top) ||
+        !symtable_enter_block(st, top, ModuleBlock, (void *)mod, 0)) {
+        PySymtable_Free(st);
+        return NULL;
+    }
+
+    st->st_top = st->st_cur;
+    st->st_cur->ste_unoptimized = OPT_TOPLEVEL;
+    /* Any other top-level initialization? */
+    switch (mod->kind) {
+    case Module_kind:
+        seq = mod->v.Module.body;
+        for (i = 0; i < asdl_seq_LEN(seq); i++)
+            if (!symtable_visit_stmt(st,
+                        (stmt_ty)asdl_seq_GET(seq, i)))
+                goto error;
+        break;
+    case Expression_kind:
+        if (!symtable_visit_expr(st, mod->v.Expression.body))
+            goto error;
+        break;
+    case Interactive_kind:
+        seq = mod->v.Interactive.body;
+        for (i = 0; i < asdl_seq_LEN(seq); i++)
+            if (!symtable_visit_stmt(st,
+                        (stmt_ty)asdl_seq_GET(seq, i)))
+                goto error;
+        break;
+    case Suite_kind:
+        PyErr_SetString(PyExc_RuntimeError,
+                        "this compiler does not handle Suites");
+        goto error;
+    }
+    if (!symtable_exit_block(st, (void *)mod)) {
+        PySymtable_Free(st);
+        return NULL;
+    }
+    if (symtable_analyze(st))
+        return st;
+    PySymtable_Free(st);
+    return NULL;
  error:
-	(void) symtable_exit_block(st, (void *)mod);
-	PySymtable_Free(st);
-	return NULL;
+    (void) symtable_exit_block(st, (void *)mod);
+    PySymtable_Free(st);
+    return NULL;
 }
 
 void
 PySymtable_Free(struct symtable *st)
 {
-	Py_XDECREF(st->st_symbols);
-	Py_XDECREF(st->st_stack);
-	PyMem_Free((void *)st);
+    Py_XDECREF(st->st_symbols);
+    Py_XDECREF(st->st_stack);
+    PyMem_Free((void *)st);
 }
 
 PySTEntryObject *
 PySymtable_Lookup(struct symtable *st, void *key)
 {
-	PyObject *k, *v;
-
-	k = PyLong_FromVoidPtr(key);
-	if (k == NULL)
-		return NULL;
-	v = PyDict_GetItem(st->st_symbols, k);
-	if (v) {
-		assert(PySTEntry_Check(v));
-		Py_INCREF(v);
-	}
-	else {
-		PyErr_SetString(PyExc_KeyError,
-				"unknown symbol table entry");
-	}
-
-	Py_DECREF(k);
-	return (PySTEntryObject *)v;
+    PyObject *k, *v;
+
+    k = PyLong_FromVoidPtr(key);
+    if (k == NULL)
+        return NULL;
+    v = PyDict_GetItem(st->st_symbols, k);
+    if (v) {
+        assert(PySTEntry_Check(v));
+        Py_INCREF(v);
+    }
+    else {
+        PyErr_SetString(PyExc_KeyError,
+                        "unknown symbol table entry");
+    }
+
+    Py_DECREF(k);
+    return (PySTEntryObject *)v;
 }
 
-int 
+int
 PyST_GetScope(PySTEntryObject *ste, PyObject *name)
 {
-	PyObject *v = PyDict_GetItem(ste->ste_symbols, name);
-	if (!v)
-		return 0;
-	assert(PyInt_Check(v));
-	return (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK;
+    PyObject *v = PyDict_GetItem(ste->ste_symbols, name);
+    if (!v)
+        return 0;
+    assert(PyInt_Check(v));
+    return (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK;
 }
 
 
 /* Analyze raw symbol information to determine scope of each name.
 
    The next several functions are helpers for PySymtable_Analyze(),
-   which determines whether a name is local, global, or free.  In addition, 
+   which determines whether a name is local, global, or free.  In addition,
    it determines which local variables are cell variables; they provide
-   bindings that are used for free variables in enclosed blocks.  
+   bindings that are used for free variables in enclosed blocks.
 
-   There are also two kinds of free variables, implicit and explicit.  An 
+   There are also two kinds of free variables, implicit and explicit.  An
    explicit global is declared with the global statement.  An implicit
    global is a free variable for which the compiler has found no binding
    in an enclosing function scope.  The implicit global is either a global
@@ -328,35 +328,35 @@ PyST_GetScope(PySTEntryObject *ste, PyObject *name)
    is treated as a local.
 
    The symbol table requires two passes to determine the scope of each name.
-   The first pass collects raw facts from the AST: the name is a parameter 
+   The first pass collects raw facts from the AST: the name is a parameter
    here, the name is used by not defined here, etc.  The second pass analyzes
    these facts during a pass over the PySTEntryObjects created during pass 1.
 
    When a function is entered during the second pass, the parent passes
-   the set of all name bindings visible to its children.  These bindings 
+   the set of all name bindings visible to its children.  These bindings
    are used to determine if the variable is free or an implicit global.
    After doing the local analysis, it analyzes each of its child blocks
-   using an updated set of name bindings.  
+   using an updated set of name bindings.
 
-   The children update the free variable set.  If a local variable is free 
-   in a child, the variable is marked as a cell.  The current function must 
-   provide runtime storage for the variable that may outlive the function's 
+   The children update the free variable set.  If a local variable is free
+   in a child, the variable is marked as a cell.  The current function must
+   provide runtime storage for the variable that may outlive the function's
    frame.  Cell variables are removed from the free set before the analyze
    function returns to its parent.
-   
+
    The sets of bound and free variables are implemented as dictionaries
    mapping strings to None.
 */
 
 #define SET_SCOPE(DICT, NAME, I) { \
-	PyObject *o = PyInt_FromLong(I); \
-	if (!o) \
-		return 0; \
-	if (PyDict_SetItem((DICT), (NAME), o) < 0) { \
-		Py_DECREF(o); \
-		return 0; \
-	} \
-	Py_DECREF(o); \
+    PyObject *o = PyInt_FromLong(I); \
+    if (!o) \
+        return 0; \
+    if (PyDict_SetItem((DICT), (NAME), o) < 0) { \
+        Py_DECREF(o); \
+        return 0; \
+    } \
+    Py_DECREF(o); \
 }
 
 /* Decide on scope of name, given flags.
@@ -366,69 +366,69 @@ PyST_GetScope(PySTEntryObject *ste, PyObject *name)
    global.  A name that was global can be changed to local.
 */
 
-static int 
+static int
 analyze_name(PySTEntryObject *ste, PyObject *dict, PyObject *name, long flags,
-	     PyObject *bound, PyObject *local, PyObject *free, 
-	     PyObject *global)
+             PyObject *bound, PyObject *local, PyObject *free,
+             PyObject *global)
 {
-	if (flags & DEF_GLOBAL) {
-		if (flags & DEF_PARAM) {
-			PyErr_Format(PyExc_SyntaxError,
-				     "name '%s' is local and global",
-				     PyString_AS_STRING(name));
-			PyErr_SyntaxLocation(ste->ste_table->st_filename,
-					     ste->ste_lineno);
-			
-			return 0;
-		}
-		SET_SCOPE(dict, name, GLOBAL_EXPLICIT);
-		if (PyDict_SetItem(global, name, Py_None) < 0)
-			return 0;
-		if (bound && PyDict_GetItem(bound, name)) {
-			if (PyDict_DelItem(bound, name) < 0)
-				return 0;
-		}
-		return 1;
-	}
-	if (flags & DEF_BOUND) {
-		SET_SCOPE(dict, name, LOCAL);
-		if (PyDict_SetItem(local, name, Py_None) < 0)
-			return 0;
-		if (PyDict_GetItem(global, name)) {
-			if (PyDict_DelItem(global, name) < 0)
-				return 0;
-		}
-		return 1;
-	}
-	/* If an enclosing block has a binding for this name, it
-	   is a free variable rather than a global variable.
-	   Note that having a non-NULL bound implies that the block
-	   is nested.
-	*/
-	if (bound && PyDict_GetItem(bound, name)) {
-		SET_SCOPE(dict, name, FREE);
-		ste->ste_free = 1;
-		if (PyDict_SetItem(free, name, Py_None) < 0)
-			return 0;
-		return 1;
-	}
-	/* If a parent has a global statement, then call it global
-	   explicit?  It could also be global implicit.
-	 */
-	else if (global && PyDict_GetItem(global, name)) {
-		SET_SCOPE(dict, name, GLOBAL_IMPLICIT);
-		return 1;
-	}
-	else {
-		if (ste->ste_nested)
-			ste->ste_free = 1;
-		SET_SCOPE(dict, name, GLOBAL_IMPLICIT);
-		return 1;
-	}
-	/* Should never get here. */
-	PyErr_Format(PyExc_SystemError, "failed to set scope for %s",
-		     PyString_AS_STRING(name));
-	return 0;
+    if (flags & DEF_GLOBAL) {
+        if (flags & DEF_PARAM) {
+            PyErr_Format(PyExc_SyntaxError,
+                         "name '%s' is local and global",
+                         PyString_AS_STRING(name));
+            PyErr_SyntaxLocation(ste->ste_table->st_filename,
+                                 ste->ste_lineno);
+
+            return 0;
+        }
+        SET_SCOPE(dict, name, GLOBAL_EXPLICIT);
+        if (PyDict_SetItem(global, name, Py_None) < 0)
+            return 0;
+        if (bound && PyDict_GetItem(bound, name)) {
+            if (PyDict_DelItem(bound, name) < 0)
+                return 0;
+        }
+        return 1;
+    }
+    if (flags & DEF_BOUND) {
+        SET_SCOPE(dict, name, LOCAL);
+        if (PyDict_SetItem(local, name, Py_None) < 0)
+            return 0;
+        if (PyDict_GetItem(global, name)) {
+            if (PyDict_DelItem(global, name) < 0)
+                return 0;
+        }
+        return 1;
+    }
+    /* If an enclosing block has a binding for this name, it
+       is a free variable rather than a global variable.
+       Note that having a non-NULL bound implies that the block
+       is nested.
+    */
+    if (bound && PyDict_GetItem(bound, name)) {
+        SET_SCOPE(dict, name, FREE);
+        ste->ste_free = 1;
+        if (PyDict_SetItem(free, name, Py_None) < 0)
+            return 0;
+        return 1;
+    }
+    /* If a parent has a global statement, then call it global
+       explicit?  It could also be global implicit.
+     */
+    else if (global && PyDict_GetItem(global, name)) {
+        SET_SCOPE(dict, name, GLOBAL_IMPLICIT);
+        return 1;
+    }
+    else {
+        if (ste->ste_nested)
+            ste->ste_free = 1;
+        SET_SCOPE(dict, name, GLOBAL_IMPLICIT);
+        return 1;
+    }
+    /* Should never get here. */
+    PyErr_Format(PyExc_SystemError, "failed to set scope for %s",
+                 PyString_AS_STRING(name));
+    return 0;
 }
 
 #undef SET_SCOPE
@@ -444,152 +444,152 @@ analyze_name(PySTEntryObject *ste, PyObject *dict, PyObject *name, long flags,
 static int
 analyze_cells(PyObject *scope, PyObject *free)
 {
-        PyObject *name, *v, *w;
-	int success = 0;
-	Py_ssize_t pos = 0;
-
-	w = PyInt_FromLong(CELL);
-	if (!w)
-		return 0;
-	while (PyDict_Next(scope, &pos, &name, &v)) {
-		long flags;
-		assert(PyInt_Check(v));
-		flags = PyInt_AS_LONG(v);
-		if (flags != LOCAL)
-			continue;
-		if (!PyDict_GetItem(free, name))
-			continue;
-		/* Replace LOCAL with CELL for this name, and remove
-		   from free. It is safe to replace the value of name 
-		   in the dict, because it will not cause a resize.
-		 */
-		if (PyDict_SetItem(scope, name, w) < 0)
-			goto error;
-		if (!PyDict_DelItem(free, name) < 0)
-			goto error;
-	}
-	success = 1;
+    PyObject *name, *v, *w;
+    int success = 0;
+    Py_ssize_t pos = 0;
+
+    w = PyInt_FromLong(CELL);
+    if (!w)
+        return 0;
+    while (PyDict_Next(scope, &pos, &name, &v)) {
+        long flags;
+        assert(PyInt_Check(v));
+        flags = PyInt_AS_LONG(v);
+        if (flags != LOCAL)
+            continue;
+        if (!PyDict_GetItem(free, name))
+            continue;
+        /* Replace LOCAL with CELL for this name, and remove
+           from free. It is safe to replace the value of name
+           in the dict, because it will not cause a resize.
+         */
+        if (PyDict_SetItem(scope, name, w) < 0)
+            goto error;
+        if (!PyDict_DelItem(free, name) < 0)
+            goto error;
+    }
+    success = 1;
  error:
-	Py_DECREF(w);
-	return success;
+    Py_DECREF(w);
+    return success;
 }
 
 /* Check for illegal statements in unoptimized namespaces */
 static int
 check_unoptimized(const PySTEntryObject* ste) {
-	char buf[300];
-	const char* trailer;
-
-	if (ste->ste_type != FunctionBlock || !ste->ste_unoptimized
-	    || !(ste->ste_free || ste->ste_child_free))
-		return 1;
-
-	trailer = (ste->ste_child_free ? 
-		       "contains a nested function with free variables" :
-			       "is a nested function");
-
-	switch (ste->ste_unoptimized) {
-	case OPT_TOPLEVEL: /* exec / import * at top-level is fine */
-	case OPT_EXEC: /* qualified exec is fine */
-		return 1;
-	case OPT_IMPORT_STAR:
-		PyOS_snprintf(buf, sizeof(buf), 
-			      "import * is not allowed in function '%.100s' "
-			      "because it %s",
-			      PyString_AS_STRING(ste->ste_name), trailer);
-		break;
-	case OPT_BARE_EXEC:
-		PyOS_snprintf(buf, sizeof(buf),
-			      "unqualified exec is not allowed in function "
-			      "'%.100s' it %s",
-			      PyString_AS_STRING(ste->ste_name), trailer);
-		break;
-	default:
-		PyOS_snprintf(buf, sizeof(buf), 
-			      "function '%.100s' uses import * and bare exec, "
-			      "which are illegal because it %s",
-			      PyString_AS_STRING(ste->ste_name), trailer);
-		break;
-	}
-
-	PyErr_SetString(PyExc_SyntaxError, buf);
-	PyErr_SyntaxLocation(ste->ste_table->st_filename, 
-			     ste->ste_opt_lineno);
-	return 0;
+    char buf[300];
+    const char* trailer;
+
+    if (ste->ste_type != FunctionBlock || !ste->ste_unoptimized
+        || !(ste->ste_free || ste->ste_child_free))
+        return 1;
+
+    trailer = (ste->ste_child_free ?
+                   "contains a nested function with free variables" :
+                   "is a nested function");
+
+    switch (ste->ste_unoptimized) {
+    case OPT_TOPLEVEL: /* exec / import * at top-level is fine */
+    case OPT_EXEC: /* qualified exec is fine */
+        return 1;
+    case OPT_IMPORT_STAR:
+        PyOS_snprintf(buf, sizeof(buf),
+                      "import * is not allowed in function '%.100s' "
+                      "because it %s",
+                      PyString_AS_STRING(ste->ste_name), trailer);
+        break;
+    case OPT_BARE_EXEC:
+        PyOS_snprintf(buf, sizeof(buf),
+                      "unqualified exec is not allowed in function "
+                      "'%.100s' it %s",
+                      PyString_AS_STRING(ste->ste_name), trailer);
+        break;
+    default:
+        PyOS_snprintf(buf, sizeof(buf),
+                      "function '%.100s' uses import * and bare exec, "
+                      "which are illegal because it %s",
+                      PyString_AS_STRING(ste->ste_name), trailer);
+        break;
+    }
+
+    PyErr_SetString(PyExc_SyntaxError, buf);
+    PyErr_SyntaxLocation(ste->ste_table->st_filename,
+                         ste->ste_opt_lineno);
+    return 0;
 }
 
-/* Enter the final scope information into the st_symbols dict. 
- * 
+/* Enter the final scope information into the st_symbols dict.
+ *
  * All arguments are dicts.  Modifies symbols, others are read-only.
 */
 static int
-update_symbols(PyObject *symbols, PyObject *scope, 
+update_symbols(PyObject *symbols, PyObject *scope,
                PyObject *bound, PyObject *free, int classflag)
 {
-	PyObject *name, *v, *u, *w, *free_value = NULL;
-	Py_ssize_t pos = 0;
-
-	while (PyDict_Next(symbols, &pos, &name, &v)) {
-		long i, flags;
-		assert(PyInt_Check(v));
-		flags = PyInt_AS_LONG(v);
-		w = PyDict_GetItem(scope, name);
-		assert(w && PyInt_Check(w));
-		i = PyInt_AS_LONG(w);
-		flags |= (i << SCOPE_OFF);
-		u = PyInt_FromLong(flags);
-		if (!u)
-			return 0;
-		if (PyDict_SetItem(symbols, name, u) < 0) {
-			Py_DECREF(u);
-			return 0;
-		}
-		Py_DECREF(u);
-	}
-
-        free_value = PyInt_FromLong(FREE << SCOPE_OFF);
-        if (!free_value)
-		return 0;
-
-        /* add a free variable when it's only use is for creating a closure */
-        pos = 0;
-	while (PyDict_Next(free, &pos, &name, &v)) {
-		PyObject *o = PyDict_GetItem(symbols, name);
-
-		if (o) {
-			/* It could be a free variable in a method of
-			   the class that has the same name as a local
-			   or global in the class scope.
-			*/
-			if  (classflag && 
-			     PyInt_AS_LONG(o) & (DEF_BOUND | DEF_GLOBAL)) {
-				long i = PyInt_AS_LONG(o) | DEF_FREE_CLASS;
-				o = PyInt_FromLong(i);
-				if (!o) {
-					Py_DECREF(free_value);
-					return 0;
-				}
-				if (PyDict_SetItem(symbols, name, o) < 0) {
-					Py_DECREF(o);
-					Py_DECREF(free_value);
-					return 0;
-				}
-				Py_DECREF(o);
-			}
-			/* else it's not free, probably a cell */
-			continue;
-		}
-		if (!PyDict_GetItem(bound, name))
-			continue;       /* it's a global */
-
-		if (PyDict_SetItem(symbols, name, free_value) < 0) {
-			Py_DECREF(free_value);
-			return 0;
-		}
+    PyObject *name, *v, *u, *w, *free_value = NULL;
+    Py_ssize_t pos = 0;
+
+    while (PyDict_Next(symbols, &pos, &name, &v)) {
+        long i, flags;
+        assert(PyInt_Check(v));
+        flags = PyInt_AS_LONG(v);
+        w = PyDict_GetItem(scope, name);
+        assert(w && PyInt_Check(w));
+        i = PyInt_AS_LONG(w);
+        flags |= (i << SCOPE_OFF);
+        u = PyInt_FromLong(flags);
+        if (!u)
+            return 0;
+        if (PyDict_SetItem(symbols, name, u) < 0) {
+            Py_DECREF(u);
+            return 0;
+        }
+        Py_DECREF(u);
+    }
+
+    free_value = PyInt_FromLong(FREE << SCOPE_OFF);
+    if (!free_value)
+        return 0;
+
+    /* add a free variable when it's only use is for creating a closure */
+    pos = 0;
+    while (PyDict_Next(free, &pos, &name, &v)) {
+        PyObject *o = PyDict_GetItem(symbols, name);
+
+        if (o) {
+            /* It could be a free variable in a method of
+               the class that has the same name as a local
+               or global in the class scope.
+            */
+            if  (classflag &&
+                 PyInt_AS_LONG(o) & (DEF_BOUND | DEF_GLOBAL)) {
+                long i = PyInt_AS_LONG(o) | DEF_FREE_CLASS;
+                o = PyInt_FromLong(i);
+                if (!o) {
+                    Py_DECREF(free_value);
+                    return 0;
+                }
+                if (PyDict_SetItem(symbols, name, o) < 0) {
+                    Py_DECREF(o);
+                    Py_DECREF(free_value);
+                    return 0;
+                }
+                Py_DECREF(o);
+            }
+            /* else it's not free, probably a cell */
+            continue;
         }
-        Py_DECREF(free_value);
-	return 1;
-}   
+        if (!PyDict_GetItem(bound, name))
+            continue;       /* it's a global */
+
+        if (PyDict_SetItem(symbols, name, free_value) < 0) {
+            Py_DECREF(free_value);
+            return 0;
+        }
+    }
+    Py_DECREF(free_value);
+    return 1;
+}
 
 /* Make final symbol table decisions for block of ste.
 
@@ -612,199 +612,199 @@ update_symbols(PyObject *symbols, PyObject *scope,
 */
 
 static int
-analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free, 
-		    PyObject *global, PyObject* child_free);
+analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free,
+                    PyObject *global, PyObject* child_free);
 
 static int
-analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free, 
-	      PyObject *global)
+analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free,
+              PyObject *global)
 {
-	PyObject *name, *v, *local = NULL, *scope = NULL;
-	PyObject *newbound = NULL, *newglobal = NULL;
-	PyObject *newfree = NULL, *allfree = NULL;
-	int i, success = 0;
-	Py_ssize_t pos = 0;
-
-	local = PyDict_New();  /* collect new names bound in block */
-	if (!local)
-		goto error;
-	scope = PyDict_New(); /* collect scopes defined for each name */
-	if (!scope)
-		goto error;
-
-	/* Allocate new global and bound variable dictionaries.  These
-	   dictionaries hold the names visible in nested blocks.  For
-	   ClassBlocks, the bound and global names are initialized
-	   before analyzing names, because class bindings aren't
-	   visible in methods.  For other blocks, they are initialized
-	   after names are analyzed.
-	 */
-
-	/* TODO(jhylton): Package these dicts in a struct so that we
-	   can write reasonable helper functions?
-	*/
-	newglobal = PyDict_New();
-	if (!newglobal)
-		goto error;
-	newbound = PyDict_New();
-	if (!newbound)
-		goto error;
-	newfree = PyDict_New();
-	if (!newfree)
-		goto error;
-
-	if (ste->ste_type == ClassBlock) {
-		if (PyDict_Update(newglobal, global) < 0)
-			goto error;
-		if (bound)
-			if (PyDict_Update(newbound, bound) < 0)
-				goto error;
-	}
-
-	while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) {
-		long flags = PyInt_AS_LONG(v);
-		if (!analyze_name(ste, scope, name, flags,
-				  bound, local, free, global))
-			goto error;
-	}
-
-	if (ste->ste_type != ClassBlock) {
-		if (ste->ste_type == FunctionBlock) {
-			if (PyDict_Update(newbound, local) < 0)
-				goto error;
-		}
-		if (bound) {
-			if (PyDict_Update(newbound, bound) < 0)
-				goto error;
-		}
-		if (PyDict_Update(newglobal, global) < 0)
-			goto error;
-	}
-
-	/* Recursively call analyze_block() on each child block.
-
-	   newbound, newglobal now contain the names visible in
-	   nested blocks.  The free variables in the children will
-	   be collected in allfree.
-	*/
-	allfree = PyDict_New();
-	if (!allfree) 
-		goto error;
-	for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) {
-		PyObject *c = PyList_GET_ITEM(ste->ste_children, i);
-		PySTEntryObject* entry;
-		assert(c && PySTEntry_Check(c));
-		entry = (PySTEntryObject*)c;
-		if (!analyze_child_block(entry, newbound, newfree, newglobal,
-					 allfree))
-			goto error;
-		if (entry->ste_free || entry->ste_child_free)
-			ste->ste_child_free = 1;
-	}
-
-	if (PyDict_Update(newfree, allfree) < 0)
-		goto error;
-	if (ste->ste_type == FunctionBlock && !analyze_cells(scope, newfree))
-		goto error;
-	if (!update_symbols(ste->ste_symbols, scope, bound, newfree,
-			    ste->ste_type == ClassBlock))
-		goto error;
-	if (!check_unoptimized(ste))
-		goto error;
-
-	if (PyDict_Update(free, newfree) < 0)
-		goto error;
-	success = 1;
+    PyObject *name, *v, *local = NULL, *scope = NULL;
+    PyObject *newbound = NULL, *newglobal = NULL;
+    PyObject *newfree = NULL, *allfree = NULL;
+    int i, success = 0;
+    Py_ssize_t pos = 0;
+
+    local = PyDict_New();  /* collect new names bound in block */
+    if (!local)
+        goto error;
+    scope = PyDict_New(); /* collect scopes defined for each name */
+    if (!scope)
+        goto error;
+
+    /* Allocate new global and bound variable dictionaries.  These
+       dictionaries hold the names visible in nested blocks.  For
+       ClassBlocks, the bound and global names are initialized
+       before analyzing names, because class bindings aren't
+       visible in methods.  For other blocks, they are initialized
+       after names are analyzed.
+     */
+
+    /* TODO(jhylton): Package these dicts in a struct so that we
+       can write reasonable helper functions?
+    */
+    newglobal = PyDict_New();
+    if (!newglobal)
+        goto error;
+    newbound = PyDict_New();
+    if (!newbound)
+        goto error;
+    newfree = PyDict_New();
+    if (!newfree)
+        goto error;
+
+    if (ste->ste_type == ClassBlock) {
+        if (PyDict_Update(newglobal, global) < 0)
+            goto error;
+        if (bound)
+            if (PyDict_Update(newbound, bound) < 0)
+                goto error;
+    }
+
+    while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) {
+        long flags = PyInt_AS_LONG(v);
+        if (!analyze_name(ste, scope, name, flags,
+                          bound, local, free, global))
+            goto error;
+    }
+
+    if (ste->ste_type != ClassBlock) {
+        if (ste->ste_type == FunctionBlock) {
+            if (PyDict_Update(newbound, local) < 0)
+                goto error;
+        }
+        if (bound) {
+            if (PyDict_Update(newbound, bound) < 0)
+                goto error;
+        }
+        if (PyDict_Update(newglobal, global) < 0)
+            goto error;
+    }
+
+    /* Recursively call analyze_block() on each child block.
+
+       newbound, newglobal now contain the names visible in
+       nested blocks.  The free variables in the children will
+       be collected in allfree.
+    */
+    allfree = PyDict_New();
+    if (!allfree)
+        goto error;
+    for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) {
+        PyObject *c = PyList_GET_ITEM(ste->ste_children, i);
+        PySTEntryObject* entry;
+        assert(c && PySTEntry_Check(c));
+        entry = (PySTEntryObject*)c;
+        if (!analyze_child_block(entry, newbound, newfree, newglobal,
+                                 allfree))
+            goto error;
+        if (entry->ste_free || entry->ste_child_free)
+            ste->ste_child_free = 1;
+    }
+
+    if (PyDict_Update(newfree, allfree) < 0)
+        goto error;
+    if (ste->ste_type == FunctionBlock && !analyze_cells(scope, newfree))
+        goto error;
+    if (!update_symbols(ste->ste_symbols, scope, bound, newfree,
+                        ste->ste_type == ClassBlock))
+        goto error;
+    if (!check_unoptimized(ste))
+        goto error;
+
+    if (PyDict_Update(free, newfree) < 0)
+        goto error;
+    success = 1;
  error:
-	Py_XDECREF(local);
-	Py_XDECREF(scope);
-	Py_XDECREF(newbound);
-	Py_XDECREF(newglobal);
-	Py_XDECREF(newfree);
-	Py_XDECREF(allfree);
-	if (!success)
-		assert(PyErr_Occurred());
-	return success;
+    Py_XDECREF(local);
+    Py_XDECREF(scope);
+    Py_XDECREF(newbound);
+    Py_XDECREF(newglobal);
+    Py_XDECREF(newfree);
+    Py_XDECREF(allfree);
+    if (!success)
+        assert(PyErr_Occurred());
+    return success;
 }
 
 static int
-analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free, 
-		    PyObject *global, PyObject* child_free)
+analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free,
+                    PyObject *global, PyObject* child_free)
 {
-	PyObject *temp_bound = NULL, *temp_global = NULL, *temp_free = NULL;
-
-	/* Copy the bound and global dictionaries.
-
-	   These dictionary are used by all blocks enclosed by the
-	   current block.  The analyze_block() call modifies these
-	   dictionaries.
-
-	*/
-	temp_bound = PyDict_New();
-	if (!temp_bound)
-		goto error;
-	if (PyDict_Update(temp_bound, bound) < 0)
-		goto error;
-	temp_free = PyDict_New();
-	if (!temp_free)
-		goto error;
-	if (PyDict_Update(temp_free, free) < 0)
-		goto error;
-	temp_global = PyDict_New();
-	if (!temp_global)
-		goto error;
-	if (PyDict_Update(temp_global, global) < 0)
-		goto error;
-
-	if (!analyze_block(entry, temp_bound, temp_free, temp_global))
-		goto error;
-	if (PyDict_Update(child_free, temp_free) < 0)
-		goto error;
-	Py_DECREF(temp_bound);
-	Py_DECREF(temp_free);
-	Py_DECREF(temp_global);
-	return 1;
+    PyObject *temp_bound = NULL, *temp_global = NULL, *temp_free = NULL;
+
+    /* Copy the bound and global dictionaries.
+
+       These dictionary are used by all blocks enclosed by the
+       current block.  The analyze_block() call modifies these
+       dictionaries.
+
+    */
+    temp_bound = PyDict_New();
+    if (!temp_bound)
+        goto error;
+    if (PyDict_Update(temp_bound, bound) < 0)
+        goto error;
+    temp_free = PyDict_New();
+    if (!temp_free)
+        goto error;
+    if (PyDict_Update(temp_free, free) < 0)
+        goto error;
+    temp_global = PyDict_New();
+    if (!temp_global)
+        goto error;
+    if (PyDict_Update(temp_global, global) < 0)
+        goto error;
+
+    if (!analyze_block(entry, temp_bound, temp_free, temp_global))
+        goto error;
+    if (PyDict_Update(child_free, temp_free) < 0)
+        goto error;
+    Py_DECREF(temp_bound);
+    Py_DECREF(temp_free);
+    Py_DECREF(temp_global);
+    return 1;
  error:
-	Py_XDECREF(temp_bound);
-	Py_XDECREF(temp_free);
-	Py_XDECREF(temp_global);
-	return 0;
+    Py_XDECREF(temp_bound);
+    Py_XDECREF(temp_free);
+    Py_XDECREF(temp_global);
+    return 0;
 }
 
 static int
 symtable_analyze(struct symtable *st)
 {
-	PyObject *free, *global;
-	int r;
-
-	free = PyDict_New();
-	if (!free)
-	    return 0;
-	global = PyDict_New();
-	if (!global) {
-	    Py_DECREF(free);
-	    return 0;
-	}
-	r = analyze_block(st->st_top, NULL, free, global);
-	Py_DECREF(free);
-	Py_DECREF(global);
-	return r;
+    PyObject *free, *global;
+    int r;
+
+    free = PyDict_New();
+    if (!free)
+        return 0;
+    global = PyDict_New();
+    if (!global) {
+        Py_DECREF(free);
+        return 0;
+    }
+    r = analyze_block(st->st_top, NULL, free, global);
+    Py_DECREF(free);
+    Py_DECREF(global);
+    return r;
 }
 
 
 static int
 symtable_warn(struct symtable *st, char *msg, int lineno)
 {
-	if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, st->st_filename,
-			       lineno, NULL, NULL) < 0)	{
-		if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) {
-			PyErr_SetString(PyExc_SyntaxError, msg);
-			PyErr_SyntaxLocation(st->st_filename, 
-					     st->st_cur->ste_lineno);
-		}
-		return 0;
-	}
-	return 1;
+    if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, st->st_filename,
+                           lineno, NULL, NULL) < 0)     {
+        if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) {
+            PyErr_SetString(PyExc_SyntaxError, msg);
+            PyErr_SyntaxLocation(st->st_filename,
+                                 st->st_cur->ste_lineno);
+        }
+        return 0;
+    }
+    return 1;
 }
 
 /* symtable_enter_block() gets a reference via ste_new.
@@ -815,739 +815,739 @@ symtable_warn(struct symtable *st, char *msg, int lineno)
 static int
 symtable_exit_block(struct symtable *st, void *ast)
 {
-	Py_ssize_t end;
-
-	Py_CLEAR(st->st_cur);
-	end = PyList_GET_SIZE(st->st_stack) - 1;
-	if (end >= 0) {
-		st->st_cur = (PySTEntryObject *)PyList_GET_ITEM(st->st_stack, 
-								end);
-		if (st->st_cur == NULL)
-			return 0;
-		Py_INCREF(st->st_cur);
-		if (PySequence_DelItem(st->st_stack, end) < 0)
-			return 0;
-	}
-	return 1;
+    Py_ssize_t end;
+
+    Py_CLEAR(st->st_cur);
+    end = PyList_GET_SIZE(st->st_stack) - 1;
+    if (end >= 0) {
+        st->st_cur = (PySTEntryObject *)PyList_GET_ITEM(st->st_stack,
+                                                        end);
+        if (st->st_cur == NULL)
+            return 0;
+        Py_INCREF(st->st_cur);
+        if (PySequence_DelItem(st->st_stack, end) < 0)
+            return 0;
+    }
+    return 1;
 }
 
 static int
-symtable_enter_block(struct symtable *st, identifier name, _Py_block_ty block, 
-		     void *ast, int lineno)
+symtable_enter_block(struct symtable *st, identifier name, _Py_block_ty block,
+                     void *ast, int lineno)
 {
-	PySTEntryObject *prev = NULL;
-
-	if (st->st_cur) {
-		prev = st->st_cur;
-		if (PyList_Append(st->st_stack, (PyObject *)st->st_cur) < 0) {
-			return 0;
-		}
-		Py_DECREF(st->st_cur);
-	}
-	st->st_cur = ste_new(st, name, block, ast, lineno);
-	if (st->st_cur == NULL)
-		return 0;
-	if (name == GET_IDENTIFIER(top))
-		st->st_global = st->st_cur->ste_symbols;
-	if (prev) {
-		if (PyList_Append(prev->ste_children, 
-				  (PyObject *)st->st_cur) < 0) {
-			return 0;
-		}
-	}
-	return 1;
+    PySTEntryObject *prev = NULL;
+
+    if (st->st_cur) {
+        prev = st->st_cur;
+        if (PyList_Append(st->st_stack, (PyObject *)st->st_cur) < 0) {
+            return 0;
+        }
+        Py_DECREF(st->st_cur);
+    }
+    st->st_cur = ste_new(st, name, block, ast, lineno);
+    if (st->st_cur == NULL)
+        return 0;
+    if (name == GET_IDENTIFIER(top))
+        st->st_global = st->st_cur->ste_symbols;
+    if (prev) {
+        if (PyList_Append(prev->ste_children,
+                          (PyObject *)st->st_cur) < 0) {
+            return 0;
+        }
+    }
+    return 1;
 }
 
 static long
 symtable_lookup(struct symtable *st, PyObject *name)
 {
-	PyObject *o;
-	PyObject *mangled = _Py_Mangle(st->st_private, name);
-	if (!mangled)
-		return 0;
-	o = PyDict_GetItem(st->st_cur->ste_symbols, mangled);
-	Py_DECREF(mangled);
-	if (!o)
-		return 0;
-	return PyInt_AsLong(o);
+    PyObject *o;
+    PyObject *mangled = _Py_Mangle(st->st_private, name);
+    if (!mangled)
+        return 0;
+    o = PyDict_GetItem(st->st_cur->ste_symbols, mangled);
+    Py_DECREF(mangled);
+    if (!o)
+        return 0;
+    return PyInt_AsLong(o);
 }
 
 static int
-symtable_add_def(struct symtable *st, PyObject *name, int flag) 
+symtable_add_def(struct symtable *st, PyObject *name, int flag)
 {
-	PyObject *o;
-	PyObject *dict;
-	long val;
-	PyObject *mangled = _Py_Mangle(st->st_private, name);
-
-	if (!mangled)
-		return 0;
-	dict = st->st_cur->ste_symbols;
-	if ((o = PyDict_GetItem(dict, mangled))) {
-	    val = PyInt_AS_LONG(o);
-	    if ((flag & DEF_PARAM) && (val & DEF_PARAM)) {
-		    /* Is it better to use 'mangled' or 'name' here? */
-		    PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT,
-				 PyString_AsString(name));
-		    PyErr_SyntaxLocation(st->st_filename,
-				       st->st_cur->ste_lineno);
-		    goto error;
-	    }
-	    val |= flag;
-	} else
-	    val = flag;
-	o = PyInt_FromLong(val);
+    PyObject *o;
+    PyObject *dict;
+    long val;
+    PyObject *mangled = _Py_Mangle(st->st_private, name);
+
+    if (!mangled)
+        return 0;
+    dict = st->st_cur->ste_symbols;
+    if ((o = PyDict_GetItem(dict, mangled))) {
+        val = PyInt_AS_LONG(o);
+        if ((flag & DEF_PARAM) && (val & DEF_PARAM)) {
+            /* Is it better to use 'mangled' or 'name' here? */
+            PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT,
+                         PyString_AsString(name));
+            PyErr_SyntaxLocation(st->st_filename,
+                               st->st_cur->ste_lineno);
+            goto error;
+        }
+        val |= flag;
+    } else
+        val = flag;
+    o = PyInt_FromLong(val);
+    if (o == NULL)
+        goto error;
+    if (PyDict_SetItem(dict, mangled, o) < 0) {
+        Py_DECREF(o);
+        goto error;
+    }
+    Py_DECREF(o);
+
+    if (flag & DEF_PARAM) {
+        if (PyList_Append(st->st_cur->ste_varnames, mangled) < 0)
+            goto error;
+    } else      if (flag & DEF_GLOBAL) {
+        /* XXX need to update DEF_GLOBAL for other flags too;
+           perhaps only DEF_FREE_GLOBAL */
+        val = flag;
+        if ((o = PyDict_GetItem(st->st_global, mangled))) {
+            val |= PyInt_AS_LONG(o);
+        }
+        o = PyInt_FromLong(val);
         if (o == NULL)
-	    goto error;
-	if (PyDict_SetItem(dict, mangled, o) < 0) {
-		Py_DECREF(o);
-		goto error;
-	}
-	Py_DECREF(o);
-
-	if (flag & DEF_PARAM) {
-		if (PyList_Append(st->st_cur->ste_varnames, mangled) < 0)
-			goto error;
-	} else	if (flag & DEF_GLOBAL) {
-		/* XXX need to update DEF_GLOBAL for other flags too;
-		   perhaps only DEF_FREE_GLOBAL */
-		val = flag;
-		if ((o = PyDict_GetItem(st->st_global, mangled))) {
-			val |= PyInt_AS_LONG(o);
-		}
-		o = PyInt_FromLong(val);
-		if (o == NULL)
-			goto error;
-		if (PyDict_SetItem(st->st_global, mangled, o) < 0) {
-			Py_DECREF(o);
-			goto error;
-		}
-		Py_DECREF(o);
-	}
-	Py_DECREF(mangled);
-	return 1;
+            goto error;
+        if (PyDict_SetItem(st->st_global, mangled, o) < 0) {
+            Py_DECREF(o);
+            goto error;
+        }
+        Py_DECREF(o);
+    }
+    Py_DECREF(mangled);
+    return 1;
 
 error:
-	Py_DECREF(mangled);
-	return 0;
+    Py_DECREF(mangled);
+    return 0;
 }
 
 /* VISIT, VISIT_SEQ and VIST_SEQ_TAIL take an ASDL type as their second argument.
    They use the ASDL name to synthesize the name of the C type and the visit
-   function. 
-   
+   function.
+
    VISIT_SEQ_TAIL permits the start of an ASDL sequence to be skipped, which is
    useful if the first node in the sequence requires special treatment.
 */
 
 #define VISIT(ST, TYPE, V) \
-	if (!symtable_visit_ ## TYPE((ST), (V))) \
-		return 0; 
+    if (!symtable_visit_ ## TYPE((ST), (V))) \
+        return 0;
 
 #define VISIT_IN_BLOCK(ST, TYPE, V, S) \
-	if (!symtable_visit_ ## TYPE((ST), (V))) { \
-		symtable_exit_block((ST), (S)); \
-		return 0; \
-	}
+    if (!symtable_visit_ ## TYPE((ST), (V))) { \
+        symtable_exit_block((ST), (S)); \
+        return 0; \
+    }
 
 #define VISIT_SEQ(ST, TYPE, SEQ) { \
-	int i; \
-	asdl_seq *seq = (SEQ); /* avoid variable capture */ \
-	for (i = 0; i < asdl_seq_LEN(seq); i++) { \
-		TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
-		if (!symtable_visit_ ## TYPE((ST), elt)) \
-			return 0; \
-	} \
+    int i; \
+    asdl_seq *seq = (SEQ); /* avoid variable capture */ \
+    for (i = 0; i < asdl_seq_LEN(seq); i++) { \
+        TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
+        if (!symtable_visit_ ## TYPE((ST), elt)) \
+            return 0; \
+    } \
 }
 
 #define VISIT_SEQ_IN_BLOCK(ST, TYPE, SEQ, S) { \
-	int i; \
-	asdl_seq *seq = (SEQ); /* avoid variable capture */ \
-	for (i = 0; i < asdl_seq_LEN(seq); i++) { \
-		TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
-		if (!symtable_visit_ ## TYPE((ST), elt)) { \
-			symtable_exit_block((ST), (S)); \
-			return 0; \
-		} \
-	} \
+    int i; \
+    asdl_seq *seq = (SEQ); /* avoid variable capture */ \
+    for (i = 0; i < asdl_seq_LEN(seq); i++) { \
+        TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
+        if (!symtable_visit_ ## TYPE((ST), elt)) { \
+            symtable_exit_block((ST), (S)); \
+            return 0; \
+        } \
+    } \
 }
 
 #define VISIT_SEQ_TAIL(ST, TYPE, SEQ, START) { \
-	int i; \
-	asdl_seq *seq = (SEQ); /* avoid variable capture */ \
-	for (i = (START); i < asdl_seq_LEN(seq); i++) { \
-		TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
-		if (!symtable_visit_ ## TYPE((ST), elt)) \
-			return 0; \
-	} \
+    int i; \
+    asdl_seq *seq = (SEQ); /* avoid variable capture */ \
+    for (i = (START); i < asdl_seq_LEN(seq); i++) { \
+        TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
+        if (!symtable_visit_ ## TYPE((ST), elt)) \
+            return 0; \
+    } \
 }
 
 #define VISIT_SEQ_TAIL_IN_BLOCK(ST, TYPE, SEQ, START, S) { \
-	int i; \
-	asdl_seq *seq = (SEQ); /* avoid variable capture */ \
-	for (i = (START); i < asdl_seq_LEN(seq); i++) { \
-		TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
-		if (!symtable_visit_ ## TYPE((ST), elt)) { \
-			symtable_exit_block((ST), (S)); \
-			return 0; \
-		} \
-	} \
+    int i; \
+    asdl_seq *seq = (SEQ); /* avoid variable capture */ \
+    for (i = (START); i < asdl_seq_LEN(seq); i++) { \
+        TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
+        if (!symtable_visit_ ## TYPE((ST), elt)) { \
+            symtable_exit_block((ST), (S)); \
+            return 0; \
+        } \
+    } \
 }
 
 static int
 symtable_visit_stmt(struct symtable *st, stmt_ty s)
 {
-	switch (s->kind) {
-        case FunctionDef_kind:
-		if (!symtable_add_def(st, s->v.FunctionDef.name, DEF_LOCAL))
-			return 0;
-		if (s->v.FunctionDef.args->defaults)
-			VISIT_SEQ(st, expr, s->v.FunctionDef.args->defaults);
-		if (s->v.FunctionDef.decorator_list)
-			VISIT_SEQ(st, expr, s->v.FunctionDef.decorator_list);
-		if (!symtable_enter_block(st, s->v.FunctionDef.name, 
-					  FunctionBlock, (void *)s, s->lineno))
-			return 0;
-		VISIT_IN_BLOCK(st, arguments, s->v.FunctionDef.args, s);
-		VISIT_SEQ_IN_BLOCK(st, stmt, s->v.FunctionDef.body, s);
-		if (!symtable_exit_block(st, s))
-			return 0;
-		break;
-        case ClassDef_kind: {
-		PyObject *tmp;
-		if (!symtable_add_def(st, s->v.ClassDef.name, DEF_LOCAL))
-			return 0;
-		VISIT_SEQ(st, expr, s->v.ClassDef.bases);
-		if (s->v.ClassDef.decorator_list)
-			VISIT_SEQ(st, expr, s->v.ClassDef.decorator_list);
-		if (!symtable_enter_block(st, s->v.ClassDef.name, ClassBlock, 
-					  (void *)s, s->lineno))
-			return 0;
-		tmp = st->st_private;
-		st->st_private = s->v.ClassDef.name;
-		VISIT_SEQ_IN_BLOCK(st, stmt, s->v.ClassDef.body, s);
-		st->st_private = tmp;
-		if (!symtable_exit_block(st, s))
-			return 0;
-		break;
-	}
-        case Return_kind:
-		if (s->v.Return.value) {
-			VISIT(st, expr, s->v.Return.value);
-			st->st_cur->ste_returns_value = 1;
-			if (st->st_cur->ste_generator) {
-				PyErr_SetString(PyExc_SyntaxError,
-					RETURN_VAL_IN_GENERATOR);
-			        PyErr_SyntaxLocation(st->st_filename,
-				             s->lineno);
-				return 0;
-			}
-		}
-		break;
-        case Delete_kind:
-		VISIT_SEQ(st, expr, s->v.Delete.targets);
-		break;
-        case Assign_kind:
-		VISIT_SEQ(st, expr, s->v.Assign.targets);
-		VISIT(st, expr, s->v.Assign.value);
-		break;
-        case AugAssign_kind:
-		VISIT(st, expr, s->v.AugAssign.target);
-		VISIT(st, expr, s->v.AugAssign.value);
-		break;
-        case Print_kind:
-		if (s->v.Print.dest)
-			VISIT(st, expr, s->v.Print.dest);
-		VISIT_SEQ(st, expr, s->v.Print.values);
-		break;
-        case For_kind:
-		VISIT(st, expr, s->v.For.target);
-		VISIT(st, expr, s->v.For.iter);
-		VISIT_SEQ(st, stmt, s->v.For.body);
-		if (s->v.For.orelse)
-			VISIT_SEQ(st, stmt, s->v.For.orelse);
-		break;
-        case While_kind:
-		VISIT(st, expr, s->v.While.test);
-		VISIT_SEQ(st, stmt, s->v.While.body);
-		if (s->v.While.orelse)
-			VISIT_SEQ(st, stmt, s->v.While.orelse);
-		break;
-        case If_kind:
-		/* XXX if 0: and lookup_yield() hacks */
-		VISIT(st, expr, s->v.If.test);
-		VISIT_SEQ(st, stmt, s->v.If.body);
-		if (s->v.If.orelse)
-			VISIT_SEQ(st, stmt, s->v.If.orelse);
-		break;
-        case Raise_kind:
-		if (s->v.Raise.type) {
-			VISIT(st, expr, s->v.Raise.type);
-			if (s->v.Raise.inst) {
-				VISIT(st, expr, s->v.Raise.inst);
-				if (s->v.Raise.tback)
-					VISIT(st, expr, s->v.Raise.tback);
-			}
-		}
-		break;
-        case TryExcept_kind:
-		VISIT_SEQ(st, stmt, s->v.TryExcept.body);
-		VISIT_SEQ(st, stmt, s->v.TryExcept.orelse);
-		VISIT_SEQ(st, excepthandler, s->v.TryExcept.handlers);
-		break;
-        case TryFinally_kind:
-		VISIT_SEQ(st, stmt, s->v.TryFinally.body);
-		VISIT_SEQ(st, stmt, s->v.TryFinally.finalbody);
-		break;
-        case Assert_kind:
-		VISIT(st, expr, s->v.Assert.test);
-		if (s->v.Assert.msg)
-			VISIT(st, expr, s->v.Assert.msg);
-		break;
-        case Import_kind:
-		VISIT_SEQ(st, alias, s->v.Import.names);
-		/* XXX Don't have the lineno available inside
-		   visit_alias */
-		if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno)
-			st->st_cur->ste_opt_lineno = s->lineno;
-		break;
-        case ImportFrom_kind:
-		VISIT_SEQ(st, alias, s->v.ImportFrom.names);
-		/* XXX Don't have the lineno available inside
-		   visit_alias */
-		if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno)
-			st->st_cur->ste_opt_lineno = s->lineno;
-		break;
-        case Exec_kind:
-		VISIT(st, expr, s->v.Exec.body);
-		if (!st->st_cur->ste_opt_lineno)
-			st->st_cur->ste_opt_lineno = s->lineno;
-		if (s->v.Exec.globals) {
-			st->st_cur->ste_unoptimized |= OPT_EXEC;
-			VISIT(st, expr, s->v.Exec.globals);
-			if (s->v.Exec.locals) 
-				VISIT(st, expr, s->v.Exec.locals);
-		} else {
-			st->st_cur->ste_unoptimized |= OPT_BARE_EXEC;
-		}
-		break;
-        case Global_kind: {
-		int i;
-		asdl_seq *seq = s->v.Global.names;
-		for (i = 0; i < asdl_seq_LEN(seq); i++) {
-			identifier name = (identifier)asdl_seq_GET(seq, i);
-			char *c_name = PyString_AS_STRING(name);
-			long cur = symtable_lookup(st, name);
-			if (cur < 0)
-				return 0;
-			if (cur & (DEF_LOCAL | USE)) {
-				char buf[256];
-				if (cur & DEF_LOCAL) 
-					PyOS_snprintf(buf, sizeof(buf),
-						      GLOBAL_AFTER_ASSIGN,
-						      c_name);
-				else
-					PyOS_snprintf(buf, sizeof(buf),
-						      GLOBAL_AFTER_USE,
-						      c_name);
-				if (!symtable_warn(st, buf, s->lineno))
-                                    return 0;
-			}
-			if (!symtable_add_def(st, name, DEF_GLOBAL))
-				return 0;
-		}
-		break;
-	}
-        case Expr_kind:
-		VISIT(st, expr, s->v.Expr.value);
-		break;
-        case Pass_kind:
-        case Break_kind:
-        case Continue_kind:
-		/* nothing to do here */
-		break;
-        case With_kind:
-                VISIT(st, expr, s->v.With.context_expr);
-                if (s->v.With.optional_vars) {
-                        VISIT(st, expr, s->v.With.optional_vars);
-                }
-                VISIT_SEQ(st, stmt, s->v.With.body);
-                break;
-	}
-	return 1;
+    switch (s->kind) {
+    case FunctionDef_kind:
+        if (!symtable_add_def(st, s->v.FunctionDef.name, DEF_LOCAL))
+            return 0;
+        if (s->v.FunctionDef.args->defaults)
+            VISIT_SEQ(st, expr, s->v.FunctionDef.args->defaults);
+        if (s->v.FunctionDef.decorator_list)
+            VISIT_SEQ(st, expr, s->v.FunctionDef.decorator_list);
+        if (!symtable_enter_block(st, s->v.FunctionDef.name,
+                                  FunctionBlock, (void *)s, s->lineno))
+            return 0;
+        VISIT_IN_BLOCK(st, arguments, s->v.FunctionDef.args, s);
+        VISIT_SEQ_IN_BLOCK(st, stmt, s->v.FunctionDef.body, s);
+        if (!symtable_exit_block(st, s))
+            return 0;
+        break;
+    case ClassDef_kind: {
+        PyObject *tmp;
+        if (!symtable_add_def(st, s->v.ClassDef.name, DEF_LOCAL))
+            return 0;
+        VISIT_SEQ(st, expr, s->v.ClassDef.bases);
+        if (s->v.ClassDef.decorator_list)
+            VISIT_SEQ(st, expr, s->v.ClassDef.decorator_list);
+        if (!symtable_enter_block(st, s->v.ClassDef.name, ClassBlock,
+                                  (void *)s, s->lineno))
+            return 0;
+        tmp = st->st_private;
+        st->st_private = s->v.ClassDef.name;
+        VISIT_SEQ_IN_BLOCK(st, stmt, s->v.ClassDef.body, s);
+        st->st_private = tmp;
+        if (!symtable_exit_block(st, s))
+            return 0;
+        break;
+    }
+    case Return_kind:
+        if (s->v.Return.value) {
+            VISIT(st, expr, s->v.Return.value);
+            st->st_cur->ste_returns_value = 1;
+            if (st->st_cur->ste_generator) {
+                PyErr_SetString(PyExc_SyntaxError,
+                    RETURN_VAL_IN_GENERATOR);
+                PyErr_SyntaxLocation(st->st_filename,
+                             s->lineno);
+                return 0;
+            }
+        }
+        break;
+    case Delete_kind:
+        VISIT_SEQ(st, expr, s->v.Delete.targets);
+        break;
+    case Assign_kind:
+        VISIT_SEQ(st, expr, s->v.Assign.targets);
+        VISIT(st, expr, s->v.Assign.value);
+        break;
+    case AugAssign_kind:
+        VISIT(st, expr, s->v.AugAssign.target);
+        VISIT(st, expr, s->v.AugAssign.value);
+        break;
+    case Print_kind:
+        if (s->v.Print.dest)
+            VISIT(st, expr, s->v.Print.dest);
+        VISIT_SEQ(st, expr, s->v.Print.values);
+        break;
+    case For_kind:
+        VISIT(st, expr, s->v.For.target);
+        VISIT(st, expr, s->v.For.iter);
+        VISIT_SEQ(st, stmt, s->v.For.body);
+        if (s->v.For.orelse)
+            VISIT_SEQ(st, stmt, s->v.For.orelse);
+        break;
+    case While_kind:
+        VISIT(st, expr, s->v.While.test);
+        VISIT_SEQ(st, stmt, s->v.While.body);
+        if (s->v.While.orelse)
+            VISIT_SEQ(st, stmt, s->v.While.orelse);
+        break;
+    case If_kind:
+        /* XXX if 0: and lookup_yield() hacks */
+        VISIT(st, expr, s->v.If.test);
+        VISIT_SEQ(st, stmt, s->v.If.body);
+        if (s->v.If.orelse)
+            VISIT_SEQ(st, stmt, s->v.If.orelse);
+        break;
+    case Raise_kind:
+        if (s->v.Raise.type) {
+            VISIT(st, expr, s->v.Raise.type);
+            if (s->v.Raise.inst) {
+                VISIT(st, expr, s->v.Raise.inst);
+                if (s->v.Raise.tback)
+                    VISIT(st, expr, s->v.Raise.tback);
+            }
+        }
+        break;
+    case TryExcept_kind:
+        VISIT_SEQ(st, stmt, s->v.TryExcept.body);
+        VISIT_SEQ(st, stmt, s->v.TryExcept.orelse);
+        VISIT_SEQ(st, excepthandler, s->v.TryExcept.handlers);
+        break;
+    case TryFinally_kind:
+        VISIT_SEQ(st, stmt, s->v.TryFinally.body);
+        VISIT_SEQ(st, stmt, s->v.TryFinally.finalbody);
+        break;
+    case Assert_kind:
+        VISIT(st, expr, s->v.Assert.test);
+        if (s->v.Assert.msg)
+            VISIT(st, expr, s->v.Assert.msg);
+        break;
+    case Import_kind:
+        VISIT_SEQ(st, alias, s->v.Import.names);
+        /* XXX Don't have the lineno available inside
+           visit_alias */
+        if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno)
+            st->st_cur->ste_opt_lineno = s->lineno;
+        break;
+    case ImportFrom_kind:
+        VISIT_SEQ(st, alias, s->v.ImportFrom.names);
+        /* XXX Don't have the lineno available inside
+           visit_alias */
+        if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno)
+            st->st_cur->ste_opt_lineno = s->lineno;
+        break;
+    case Exec_kind:
+        VISIT(st, expr, s->v.Exec.body);
+        if (!st->st_cur->ste_opt_lineno)
+            st->st_cur->ste_opt_lineno = s->lineno;
+        if (s->v.Exec.globals) {
+            st->st_cur->ste_unoptimized |= OPT_EXEC;
+            VISIT(st, expr, s->v.Exec.globals);
+            if (s->v.Exec.locals)
+                VISIT(st, expr, s->v.Exec.locals);
+        } else {
+            st->st_cur->ste_unoptimized |= OPT_BARE_EXEC;
+        }
+        break;
+    case Global_kind: {
+        int i;
+        asdl_seq *seq = s->v.Global.names;
+        for (i = 0; i < asdl_seq_LEN(seq); i++) {
+            identifier name = (identifier)asdl_seq_GET(seq, i);
+            char *c_name = PyString_AS_STRING(name);
+            long cur = symtable_lookup(st, name);
+            if (cur < 0)
+                return 0;
+            if (cur & (DEF_LOCAL | USE)) {
+                char buf[256];
+                if (cur & DEF_LOCAL)
+                    PyOS_snprintf(buf, sizeof(buf),
+                                  GLOBAL_AFTER_ASSIGN,
+                                  c_name);
+                else
+                    PyOS_snprintf(buf, sizeof(buf),
+                                  GLOBAL_AFTER_USE,
+                                  c_name);
+                if (!symtable_warn(st, buf, s->lineno))
+                    return 0;
+            }
+            if (!symtable_add_def(st, name, DEF_GLOBAL))
+                return 0;
+        }
+        break;
+    }
+    case Expr_kind:
+        VISIT(st, expr, s->v.Expr.value);
+        break;
+    case Pass_kind:
+    case Break_kind:
+    case Continue_kind:
+        /* nothing to do here */
+        break;
+    case With_kind:
+        VISIT(st, expr, s->v.With.context_expr);
+        if (s->v.With.optional_vars) {
+            VISIT(st, expr, s->v.With.optional_vars);
+        }
+        VISIT_SEQ(st, stmt, s->v.With.body);
+        break;
+    }
+    return 1;
 }
 
-static int 
+static int
 symtable_visit_expr(struct symtable *st, expr_ty e)
 {
-	switch (e->kind) {
-        case BoolOp_kind:
-		VISIT_SEQ(st, expr, e->v.BoolOp.values);
-		break;
-        case BinOp_kind:
-		VISIT(st, expr, e->v.BinOp.left);
-		VISIT(st, expr, e->v.BinOp.right);
-		break;
-        case UnaryOp_kind:
-		VISIT(st, expr, e->v.UnaryOp.operand);
-		break;
-        case Lambda_kind: {
-		if (!GET_IDENTIFIER(lambda))
-			return 0;
-		if (e->v.Lambda.args->defaults)
-			VISIT_SEQ(st, expr, e->v.Lambda.args->defaults);
-		if (!symtable_enter_block(st, lambda,
-                                          FunctionBlock, (void *)e, e->lineno))
-			return 0;
-		VISIT_IN_BLOCK(st, arguments, e->v.Lambda.args, (void*)e);
-		VISIT_IN_BLOCK(st, expr, e->v.Lambda.body, (void*)e);
-		if (!symtable_exit_block(st, (void *)e))
-			return 0;
-		break;
-	}
-	case IfExp_kind:
-		VISIT(st, expr, e->v.IfExp.test);
-		VISIT(st, expr, e->v.IfExp.body);
-		VISIT(st, expr, e->v.IfExp.orelse);
-		break;
-        case Dict_kind:
-		VISIT_SEQ(st, expr, e->v.Dict.keys);
-		VISIT_SEQ(st, expr, e->v.Dict.values);
-		break;
-        case Set_kind:
-		VISIT_SEQ(st, expr, e->v.Set.elts);
-		break;
-        case ListComp_kind:
-		VISIT(st, expr, e->v.ListComp.elt);
-		VISIT_SEQ(st, comprehension, e->v.ListComp.generators);
-		break;
-        case GeneratorExp_kind:
-		if (!symtable_visit_genexp(st, e))
-			return 0;
-		break;
-	case SetComp_kind:
-		if (!symtable_visit_setcomp(st, e))
-			return 0;
-		break;
-	case DictComp_kind:
-		if (!symtable_visit_dictcomp(st, e))
-			return 0;
-		break;
-        case Yield_kind:
-		if (e->v.Yield.value)
-			VISIT(st, expr, e->v.Yield.value);
-                st->st_cur->ste_generator = 1;
-		if (st->st_cur->ste_returns_value) {
-			PyErr_SetString(PyExc_SyntaxError,
-				RETURN_VAL_IN_GENERATOR);
-		        PyErr_SyntaxLocation(st->st_filename,
-			             e->lineno);
-			return 0;
-		}
-		break;
-        case Compare_kind:
-		VISIT(st, expr, e->v.Compare.left);
-		VISIT_SEQ(st, expr, e->v.Compare.comparators);
-		break;
-        case Call_kind:
-		VISIT(st, expr, e->v.Call.func);
-		VISIT_SEQ(st, expr, e->v.Call.args);
-		VISIT_SEQ(st, keyword, e->v.Call.keywords);
-		if (e->v.Call.starargs)
-			VISIT(st, expr, e->v.Call.starargs);
-		if (e->v.Call.kwargs)
-			VISIT(st, expr, e->v.Call.kwargs);
-		break;
-        case Repr_kind:
-		VISIT(st, expr, e->v.Repr.value);
-		break;
-        case Num_kind:
-        case Str_kind:
-		/* Nothing to do here. */
-		break;
-	/* The following exprs can be assignment targets. */
-        case Attribute_kind:
-		VISIT(st, expr, e->v.Attribute.value);
-		break;
-        case Subscript_kind:
-		VISIT(st, expr, e->v.Subscript.value);
-		VISIT(st, slice, e->v.Subscript.slice);
-		break;
-        case Name_kind:
-		if (!symtable_add_def(st, e->v.Name.id, 
-				      e->v.Name.ctx == Load ? USE : DEF_LOCAL))
-			return 0;
-		break;
-	/* child nodes of List and Tuple will have expr_context set */
-        case List_kind:
-		VISIT_SEQ(st, expr, e->v.List.elts);
-		break;
-        case Tuple_kind:
-		VISIT_SEQ(st, expr, e->v.Tuple.elts);
-		break;
-	}
-	return 1;
+    switch (e->kind) {
+    case BoolOp_kind:
+        VISIT_SEQ(st, expr, e->v.BoolOp.values);
+        break;
+    case BinOp_kind:
+        VISIT(st, expr, e->v.BinOp.left);
+        VISIT(st, expr, e->v.BinOp.right);
+        break;
+    case UnaryOp_kind:
+        VISIT(st, expr, e->v.UnaryOp.operand);
+        break;
+    case Lambda_kind: {
+        if (!GET_IDENTIFIER(lambda))
+            return 0;
+        if (e->v.Lambda.args->defaults)
+            VISIT_SEQ(st, expr, e->v.Lambda.args->defaults);
+        if (!symtable_enter_block(st, lambda,
+                                  FunctionBlock, (void *)e, e->lineno))
+            return 0;
+        VISIT_IN_BLOCK(st, arguments, e->v.Lambda.args, (void*)e);
+        VISIT_IN_BLOCK(st, expr, e->v.Lambda.body, (void*)e);
+        if (!symtable_exit_block(st, (void *)e))
+            return 0;
+        break;
+    }
+    case IfExp_kind:
+        VISIT(st, expr, e->v.IfExp.test);
+        VISIT(st, expr, e->v.IfExp.body);
+        VISIT(st, expr, e->v.IfExp.orelse);
+        break;
+    case Dict_kind:
+        VISIT_SEQ(st, expr, e->v.Dict.keys);
+        VISIT_SEQ(st, expr, e->v.Dict.values);
+        break;
+    case Set_kind:
+        VISIT_SEQ(st, expr, e->v.Set.elts);
+        break;
+    case ListComp_kind:
+        VISIT(st, expr, e->v.ListComp.elt);
+        VISIT_SEQ(st, comprehension, e->v.ListComp.generators);
+        break;
+    case GeneratorExp_kind:
+        if (!symtable_visit_genexp(st, e))
+            return 0;
+        break;
+    case SetComp_kind:
+        if (!symtable_visit_setcomp(st, e))
+            return 0;
+        break;
+    case DictComp_kind:
+        if (!symtable_visit_dictcomp(st, e))
+            return 0;
+        break;
+    case Yield_kind:
+        if (e->v.Yield.value)
+            VISIT(st, expr, e->v.Yield.value);
+        st->st_cur->ste_generator = 1;
+        if (st->st_cur->ste_returns_value) {
+            PyErr_SetString(PyExc_SyntaxError,
+                RETURN_VAL_IN_GENERATOR);
+            PyErr_SyntaxLocation(st->st_filename,
+                         e->lineno);
+            return 0;
+        }
+        break;
+    case Compare_kind:
+        VISIT(st, expr, e->v.Compare.left);
+        VISIT_SEQ(st, expr, e->v.Compare.comparators);
+        break;
+    case Call_kind:
+        VISIT(st, expr, e->v.Call.func);
+        VISIT_SEQ(st, expr, e->v.Call.args);
+        VISIT_SEQ(st, keyword, e->v.Call.keywords);
+        if (e->v.Call.starargs)
+            VISIT(st, expr, e->v.Call.starargs);
+        if (e->v.Call.kwargs)
+            VISIT(st, expr, e->v.Call.kwargs);
+        break;
+    case Repr_kind:
+        VISIT(st, expr, e->v.Repr.value);
+        break;
+    case Num_kind:
+    case Str_kind:
+        /* Nothing to do here. */
+        break;
+    /* The following exprs can be assignment targets. */
+    case Attribute_kind:
+        VISIT(st, expr, e->v.Attribute.value);
+        break;
+    case Subscript_kind:
+        VISIT(st, expr, e->v.Subscript.value);
+        VISIT(st, slice, e->v.Subscript.slice);
+        break;
+    case Name_kind:
+        if (!symtable_add_def(st, e->v.Name.id,
+                              e->v.Name.ctx == Load ? USE : DEF_LOCAL))
+            return 0;
+        break;
+    /* child nodes of List and Tuple will have expr_context set */
+    case List_kind:
+        VISIT_SEQ(st, expr, e->v.List.elts);
+        break;
+    case Tuple_kind:
+        VISIT_SEQ(st, expr, e->v.Tuple.elts);
+        break;
+    }
+    return 1;
 }
 
 static int
 symtable_implicit_arg(struct symtable *st, int pos)
 {
-	PyObject *id = PyString_FromFormat(".%d", pos);
-	if (id == NULL)
-		return 0;
-	if (!symtable_add_def(st, id, DEF_PARAM)) {
-		Py_DECREF(id);
-		return 0;
-	}
-	Py_DECREF(id);
-	return 1;
+    PyObject *id = PyString_FromFormat(".%d", pos);
+    if (id == NULL)
+        return 0;
+    if (!symtable_add_def(st, id, DEF_PARAM)) {
+        Py_DECREF(id);
+        return 0;
+    }
+    Py_DECREF(id);
+    return 1;
 }
 
-static int 
+static int
 symtable_visit_params(struct symtable *st, asdl_seq *args, int toplevel)
 {
-	int i;
-	
-        /* go through all the toplevel arguments first */
-	for (i = 0; i < asdl_seq_LEN(args); i++) {
-		expr_ty arg = (expr_ty)asdl_seq_GET(args, i);
-		if (arg->kind == Name_kind) {
-			assert(arg->v.Name.ctx == Param ||
-                               (arg->v.Name.ctx == Store && !toplevel));
-			if (!symtable_add_def(st, arg->v.Name.id, DEF_PARAM))
-				return 0;
-		}
-		else if (arg->kind == Tuple_kind) {
-			assert(arg->v.Tuple.ctx == Store);
-			if (toplevel) {
-				if (!symtable_implicit_arg(st, i))
-					return 0;
-			}
-		}
-		else {
-		        PyErr_SetString(PyExc_SyntaxError,
-					"invalid expression in parameter list");
-		        PyErr_SyntaxLocation(st->st_filename,
-				             st->st_cur->ste_lineno);
-			return 0;
-		}
-	}
-
-	if (!toplevel) {
-		if (!symtable_visit_params_nested(st, args))
-			return 0;
-	}
-
-	return 1;
+    int i;
+
+    /* go through all the toplevel arguments first */
+    for (i = 0; i < asdl_seq_LEN(args); i++) {
+        expr_ty arg = (expr_ty)asdl_seq_GET(args, i);
+        if (arg->kind == Name_kind) {
+            assert(arg->v.Name.ctx == Param ||
+                   (arg->v.Name.ctx == Store && !toplevel));
+            if (!symtable_add_def(st, arg->v.Name.id, DEF_PARAM))
+                return 0;
+        }
+        else if (arg->kind == Tuple_kind) {
+            assert(arg->v.Tuple.ctx == Store);
+            if (toplevel) {
+                if (!symtable_implicit_arg(st, i))
+                    return 0;
+            }
+        }
+        else {
+            PyErr_SetString(PyExc_SyntaxError,
+                            "invalid expression in parameter list");
+            PyErr_SyntaxLocation(st->st_filename,
+                                 st->st_cur->ste_lineno);
+            return 0;
+        }
+    }
+
+    if (!toplevel) {
+        if (!symtable_visit_params_nested(st, args))
+            return 0;
+    }
+
+    return 1;
 }
 
 static int
 symtable_visit_params_nested(struct symtable *st, asdl_seq *args)
 {
-	int i;
-	for (i = 0; i < asdl_seq_LEN(args); i++) {
-		expr_ty arg = (expr_ty)asdl_seq_GET(args, i);
-		if (arg->kind == Tuple_kind &&
-		    !symtable_visit_params(st, arg->v.Tuple.elts, 0))
-			return 0;
-	}
-	
-	return 1;
+    int i;
+    for (i = 0; i < asdl_seq_LEN(args); i++) {
+        expr_ty arg = (expr_ty)asdl_seq_GET(args, i);
+        if (arg->kind == Tuple_kind &&
+            !symtable_visit_params(st, arg->v.Tuple.elts, 0))
+            return 0;
+    }
+
+    return 1;
 }
 
-static int 
+static int
 symtable_visit_arguments(struct symtable *st, arguments_ty a)
 {
-	/* skip default arguments inside function block
-	   XXX should ast be different?
-	*/
-	if (a->args && !symtable_visit_params(st, a->args, 1))
-		return 0;
-	if (a->vararg) {
-		if (!symtable_add_def(st, a->vararg, DEF_PARAM))
-			return 0;
-		st->st_cur->ste_varargs = 1;
-	}
-	if (a->kwarg) {
-		if (!symtable_add_def(st, a->kwarg, DEF_PARAM))
-			return 0;
-		st->st_cur->ste_varkeywords = 1;
-	}
-	if (a->args && !symtable_visit_params_nested(st, a->args))
-		return 0;
-	return 1;
+    /* skip default arguments inside function block
+       XXX should ast be different?
+    */
+    if (a->args && !symtable_visit_params(st, a->args, 1))
+        return 0;
+    if (a->vararg) {
+        if (!symtable_add_def(st, a->vararg, DEF_PARAM))
+            return 0;
+        st->st_cur->ste_varargs = 1;
+    }
+    if (a->kwarg) {
+        if (!symtable_add_def(st, a->kwarg, DEF_PARAM))
+            return 0;
+        st->st_cur->ste_varkeywords = 1;
+    }
+    if (a->args && !symtable_visit_params_nested(st, a->args))
+        return 0;
+    return 1;
 }
 
 
-static int 
+static int
 symtable_visit_excepthandler(struct symtable *st, excepthandler_ty eh)
 {
-	if (eh->v.ExceptHandler.type)
-		VISIT(st, expr, eh->v.ExceptHandler.type);
-	if (eh->v.ExceptHandler.name)
-		VISIT(st, expr, eh->v.ExceptHandler.name);
-	VISIT_SEQ(st, stmt, eh->v.ExceptHandler.body);
-	return 1;
+    if (eh->v.ExceptHandler.type)
+        VISIT(st, expr, eh->v.ExceptHandler.type);
+    if (eh->v.ExceptHandler.name)
+        VISIT(st, expr, eh->v.ExceptHandler.name);
+    VISIT_SEQ(st, stmt, eh->v.ExceptHandler.body);
+    return 1;
 }
 
 
-static int 
+static int
 symtable_visit_alias(struct symtable *st, alias_ty a)
 {
-	/* Compute store_name, the name actually bound by the import
-	   operation.  It is diferent than a->name when a->name is a
-	   dotted package name (e.g. spam.eggs) 
-	*/
-	PyObject *store_name;
-	PyObject *name = (a->asname == NULL) ? a->name : a->asname;
-	const char *base = PyString_AS_STRING(name);
-	char *dot = strchr(base, '.');
-	if (dot) {
-		store_name = PyString_FromStringAndSize(base, dot - base);
-		if (!store_name)
-			return 0;
-	}
-	else {
-		store_name = name;
-		Py_INCREF(store_name);
-	}
-	if (strcmp(PyString_AS_STRING(name), "*")) {
-		int r = symtable_add_def(st, store_name, DEF_IMPORT); 
-		Py_DECREF(store_name);
-		return r;
-	}
-	else {
-            if (st->st_cur->ste_type != ModuleBlock) {
-                int lineno = st->st_cur->ste_lineno;
-                if (!symtable_warn(st, IMPORT_STAR_WARNING, lineno)) {
-                    Py_DECREF(store_name);
-                    return 0;
-		}
-            }
-	    st->st_cur->ste_unoptimized |= OPT_IMPORT_STAR;
-	    Py_DECREF(store_name);
-	    return 1;
-	}
+    /* Compute store_name, the name actually bound by the import
+       operation.  It is diferent than a->name when a->name is a
+       dotted package name (e.g. spam.eggs)
+    */
+    PyObject *store_name;
+    PyObject *name = (a->asname == NULL) ? a->name : a->asname;
+    const char *base = PyString_AS_STRING(name);
+    char *dot = strchr(base, '.');
+    if (dot) {
+        store_name = PyString_FromStringAndSize(base, dot - base);
+        if (!store_name)
+            return 0;
+    }
+    else {
+        store_name = name;
+        Py_INCREF(store_name);
+    }
+    if (strcmp(PyString_AS_STRING(name), "*")) {
+        int r = symtable_add_def(st, store_name, DEF_IMPORT);
+        Py_DECREF(store_name);
+        return r;
+    }
+    else {
+        if (st->st_cur->ste_type != ModuleBlock) {
+        int lineno = st->st_cur->ste_lineno;
+        if (!symtable_warn(st, IMPORT_STAR_WARNING, lineno)) {
+            Py_DECREF(store_name);
+            return 0;
+        }
+        }
+        st->st_cur->ste_unoptimized |= OPT_IMPORT_STAR;
+        Py_DECREF(store_name);
+        return 1;
+    }
 }
 
 
-static int 
+static int
 symtable_visit_comprehension(struct symtable *st, comprehension_ty lc)
 {
-	VISIT(st, expr, lc->target);
-	VISIT(st, expr, lc->iter);
-	VISIT_SEQ(st, expr, lc->ifs);
-	return 1;
+    VISIT(st, expr, lc->target);
+    VISIT(st, expr, lc->iter);
+    VISIT_SEQ(st, expr, lc->ifs);
+    return 1;
 }
 
 
-static int 
+static int
 symtable_visit_keyword(struct symtable *st, keyword_ty k)
 {
-	VISIT(st, expr, k->value);
-	return 1;
+    VISIT(st, expr, k->value);
+    return 1;
 }
 
 
-static int 
+static int
 symtable_visit_slice(struct symtable *st, slice_ty s)
 {
-	switch (s->kind) {
-	case Slice_kind:
-		if (s->v.Slice.lower)
-			VISIT(st, expr, s->v.Slice.lower)
-		if (s->v.Slice.upper)
-			VISIT(st, expr, s->v.Slice.upper)
-		if (s->v.Slice.step)
-			VISIT(st, expr, s->v.Slice.step)
-		break;
-	case ExtSlice_kind:
-		VISIT_SEQ(st, slice, s->v.ExtSlice.dims)
-		break;
-	case Index_kind:
-		VISIT(st, expr, s->v.Index.value)
-		break;
-	case Ellipsis_kind:
-		break;
-	}
-	return 1;
+    switch (s->kind) {
+    case Slice_kind:
+        if (s->v.Slice.lower)
+            VISIT(st, expr, s->v.Slice.lower)
+        if (s->v.Slice.upper)
+            VISIT(st, expr, s->v.Slice.upper)
+        if (s->v.Slice.step)
+            VISIT(st, expr, s->v.Slice.step)
+        break;
+    case ExtSlice_kind:
+        VISIT_SEQ(st, slice, s->v.ExtSlice.dims)
+        break;
+    case Index_kind:
+        VISIT(st, expr, s->v.Index.value)
+        break;
+    case Ellipsis_kind:
+        break;
+    }
+    return 1;
 }
 
 static int
 symtable_new_tmpname(struct symtable *st)
 {
-	char tmpname[256];
-	identifier tmp;
-
-	PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]",
-		      ++st->st_cur->ste_tmpname);
-	tmp = PyString_InternFromString(tmpname);
-	if (!tmp)
-		return 0;
-	if (!symtable_add_def(st, tmp, DEF_LOCAL))
-		return 0;
-	Py_DECREF(tmp);
-	return 1;
+    char tmpname[256];
+    identifier tmp;
+
+    PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]",
+                  ++st->st_cur->ste_tmpname);
+    tmp = PyString_InternFromString(tmpname);
+    if (!tmp)
+        return 0;
+    if (!symtable_add_def(st, tmp, DEF_LOCAL))
+        return 0;
+    Py_DECREF(tmp);
+    return 1;
 }
 
-static int 
+static int
 symtable_handle_comprehension(struct symtable *st, expr_ty e,
                               identifier scope_name, asdl_seq *generators,
                               expr_ty elt, expr_ty value)
 {
-	int is_generator = (e->kind == GeneratorExp_kind);
-	int needs_tmp = !is_generator;
-	comprehension_ty outermost = ((comprehension_ty)
-                                        asdl_seq_GET(generators, 0));
-	/* Outermost iterator is evaluated in current scope */
-	VISIT(st, expr, outermost->iter);
-	/* Create comprehension scope for the rest */
-	if (!scope_name ||
-	    !symtable_enter_block(st, scope_name, FunctionBlock, (void *)e, 0)) {
-		return 0;
-	}
-	st->st_cur->ste_generator = is_generator;
-	/* Outermost iter is received as an argument */
-	if (!symtable_implicit_arg(st, 0)) {
-		symtable_exit_block(st, (void *)e);
-		return 0;
-	}
-	/* Allocate temporary name if needed */
-	if (needs_tmp && !symtable_new_tmpname(st)) {
-		symtable_exit_block(st, (void *)e);
-		return 0;
-	}
-	VISIT_IN_BLOCK(st, expr, outermost->target, (void*)e);
-	VISIT_SEQ_IN_BLOCK(st, expr, outermost->ifs, (void*)e);
-	VISIT_SEQ_TAIL_IN_BLOCK(st, comprehension,
-				generators, 1, (void*)e);
-	if (value)
-		VISIT_IN_BLOCK(st, expr, value, (void*)e);
-	VISIT_IN_BLOCK(st, expr, elt, (void*)e);
-	return symtable_exit_block(st, (void *)e);
+    int is_generator = (e->kind == GeneratorExp_kind);
+    int needs_tmp = !is_generator;
+    comprehension_ty outermost = ((comprehension_ty)
+                                    asdl_seq_GET(generators, 0));
+    /* Outermost iterator is evaluated in current scope */
+    VISIT(st, expr, outermost->iter);
+    /* Create comprehension scope for the rest */
+    if (!scope_name ||
+        !symtable_enter_block(st, scope_name, FunctionBlock, (void *)e, 0)) {
+        return 0;
+    }
+    st->st_cur->ste_generator = is_generator;
+    /* Outermost iter is received as an argument */
+    if (!symtable_implicit_arg(st, 0)) {
+        symtable_exit_block(st, (void *)e);
+        return 0;
+    }
+    /* Allocate temporary name if needed */
+    if (needs_tmp && !symtable_new_tmpname(st)) {
+        symtable_exit_block(st, (void *)e);
+        return 0;
+    }
+    VISIT_IN_BLOCK(st, expr, outermost->target, (void*)e);
+    VISIT_SEQ_IN_BLOCK(st, expr, outermost->ifs, (void*)e);
+    VISIT_SEQ_TAIL_IN_BLOCK(st, comprehension,
+                            generators, 1, (void*)e);
+    if (value)
+        VISIT_IN_BLOCK(st, expr, value, (void*)e);
+    VISIT_IN_BLOCK(st, expr, elt, (void*)e);
+    return symtable_exit_block(st, (void *)e);
 }
 
-static int 
+static int
 symtable_visit_genexp(struct symtable *st, expr_ty e)
 {
-	return symtable_handle_comprehension(st, e, GET_IDENTIFIER(genexpr),
-                                             e->v.GeneratorExp.generators,
-                                             e->v.GeneratorExp.elt, NULL);
+    return symtable_handle_comprehension(st, e, GET_IDENTIFIER(genexpr),
+                                         e->v.GeneratorExp.generators,
+                                         e->v.GeneratorExp.elt, NULL);
 }
 
 static int
 symtable_visit_setcomp(struct symtable *st, expr_ty e)
 {
-	return symtable_handle_comprehension(st, e, GET_IDENTIFIER(setcomp),
-					     e->v.SetComp.generators,
-					     e->v.SetComp.elt, NULL);
+    return symtable_handle_comprehension(st, e, GET_IDENTIFIER(setcomp),
+                                         e->v.SetComp.generators,
+                                         e->v.SetComp.elt, NULL);
 }
 
 static int
 symtable_visit_dictcomp(struct symtable *st, expr_ty e)
 {
-	return symtable_handle_comprehension(st, e, GET_IDENTIFIER(dictcomp),
-					     e->v.DictComp.generators,
-					     e->v.DictComp.key,
-					     e->v.DictComp.value);
+    return symtable_handle_comprehension(st, e, GET_IDENTIFIER(dictcomp),
+                                         e->v.DictComp.generators,
+                                         e->v.DictComp.key,
+                                         e->v.DictComp.value);
 }
diff --git a/Python/sysmodule.c b/Python/sysmodule.c
index 27eaad1..7cfa15d 100644
--- a/Python/sysmodule.c
+++ b/Python/sysmodule.c
@@ -49,78 +49,78 @@ extern const char *PyWin_DLLVersionString;
 PyObject *
 PySys_GetObject(char *name)
 {
-	PyThreadState *tstate = PyThreadState_GET();
-	PyObject *sd = tstate->interp->sysdict;
-	if (sd == NULL)
-		return NULL;
-	return PyDict_GetItemString(sd, name);
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *sd = tstate->interp->sysdict;
+    if (sd == NULL)
+        return NULL;
+    return PyDict_GetItemString(sd, name);
 }
 
 FILE *
 PySys_GetFile(char *name, FILE *def)
 {
-	FILE *fp = NULL;
-	PyObject *v = PySys_GetObject(name);
-	if (v != NULL && PyFile_Check(v))
-		fp = PyFile_AsFile(v);
-	if (fp == NULL)
-		fp = def;
-	return fp;
+    FILE *fp = NULL;
+    PyObject *v = PySys_GetObject(name);
+    if (v != NULL && PyFile_Check(v))
+        fp = PyFile_AsFile(v);
+    if (fp == NULL)
+        fp = def;
+    return fp;
 }
 
 int
 PySys_SetObject(char *name, PyObject *v)
 {
-	PyThreadState *tstate = PyThreadState_GET();
-	PyObject *sd = tstate->interp->sysdict;
-	if (v == NULL) {
-		if (PyDict_GetItemString(sd, name) == NULL)
-			return 0;
-		else
-			return PyDict_DelItemString(sd, name);
-	}
-	else
-		return PyDict_SetItemString(sd, name, v);
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *sd = tstate->interp->sysdict;
+    if (v == NULL) {
+        if (PyDict_GetItemString(sd, name) == NULL)
+            return 0;
+        else
+            return PyDict_DelItemString(sd, name);
+    }
+    else
+        return PyDict_SetItemString(sd, name, v);
 }
 
 static PyObject *
 sys_displayhook(PyObject *self, PyObject *o)
 {
-	PyObject *outf;
-	PyInterpreterState *interp = PyThreadState_GET()->interp;
-	PyObject *modules = interp->modules;
-	PyObject *builtins = PyDict_GetItemString(modules, "__builtin__");
-
-	if (builtins == NULL) {
-		PyErr_SetString(PyExc_RuntimeError, "lost __builtin__");
-		return NULL;
-	}
-
-	/* Print value except if None */
-	/* After printing, also assign to '_' */
-	/* Before, set '_' to None to avoid recursion */
-	if (o == Py_None) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	if (PyObject_SetAttrString(builtins, "_", Py_None) != 0)
-		return NULL;
-	if (Py_FlushLine() != 0)
-		return NULL;
-	outf = PySys_GetObject("stdout");
-	if (outf == NULL) {
-		PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
-		return NULL;
-	}
-	if (PyFile_WriteObject(o, outf, 0) != 0)
-		return NULL;
-	PyFile_SoftSpace(outf, 1);
-	if (Py_FlushLine() != 0)
-		return NULL;
-	if (PyObject_SetAttrString(builtins, "_", o) != 0)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    PyObject *outf;
+    PyInterpreterState *interp = PyThreadState_GET()->interp;
+    PyObject *modules = interp->modules;
+    PyObject *builtins = PyDict_GetItemString(modules, "__builtin__");
+
+    if (builtins == NULL) {
+        PyErr_SetString(PyExc_RuntimeError, "lost __builtin__");
+        return NULL;
+    }
+
+    /* Print value except if None */
+    /* After printing, also assign to '_' */
+    /* Before, set '_' to None to avoid recursion */
+    if (o == Py_None) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    if (PyObject_SetAttrString(builtins, "_", Py_None) != 0)
+        return NULL;
+    if (Py_FlushLine() != 0)
+        return NULL;
+    outf = PySys_GetObject("stdout");
+    if (outf == NULL) {
+        PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
+        return NULL;
+    }
+    if (PyFile_WriteObject(o, outf, 0) != 0)
+        return NULL;
+    PyFile_SoftSpace(outf, 1);
+    if (Py_FlushLine() != 0)
+        return NULL;
+    if (PyObject_SetAttrString(builtins, "_", o) != 0)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(displayhook_doc,
@@ -132,12 +132,12 @@ PyDoc_STRVAR(displayhook_doc,
 static PyObject *
 sys_excepthook(PyObject* self, PyObject* args)
 {
-	PyObject *exc, *value, *tb;
-	if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))
-		return NULL;
-	PyErr_Display(exc, value, tb);
-	Py_INCREF(Py_None);
-	return Py_None;
+    PyObject *exc, *value, *tb;
+    if (!PyArg_UnpackTuple(args, "excepthook", 3, 3, &exc, &value, &tb))
+        return NULL;
+    PyErr_Display(exc, value, tb);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(excepthook_doc,
@@ -149,14 +149,14 @@ PyDoc_STRVAR(excepthook_doc,
 static PyObject *
 sys_exc_info(PyObject *self, PyObject *noargs)
 {
-	PyThreadState *tstate;
-	tstate = PyThreadState_GET();
-	return Py_BuildValue(
-		"(OOO)",
-		tstate->exc_type != NULL ? tstate->exc_type : Py_None,
-		tstate->exc_value != NULL ? tstate->exc_value : Py_None,
-		tstate->exc_traceback != NULL ?
-			tstate->exc_traceback : Py_None);
+    PyThreadState *tstate;
+    tstate = PyThreadState_GET();
+    return Py_BuildValue(
+        "(OOO)",
+        tstate->exc_type != NULL ? tstate->exc_type : Py_None,
+        tstate->exc_value != NULL ? tstate->exc_value : Py_None,
+        tstate->exc_traceback != NULL ?
+            tstate->exc_traceback : Py_None);
 }
 
 PyDoc_STRVAR(exc_info_doc,
@@ -169,29 +169,29 @@ clause in the current stack frame or in an older stack frame."
 static PyObject *
 sys_exc_clear(PyObject *self, PyObject *noargs)
 {
-	PyThreadState *tstate;
-	PyObject *tmp_type, *tmp_value, *tmp_tb;
-
-	if (PyErr_WarnPy3k("sys.exc_clear() not supported in 3.x; "
-			   "use except clauses", 1) < 0)
-		return NULL;
-
-	tstate = PyThreadState_GET();
-	tmp_type = tstate->exc_type;
-	tmp_value = tstate->exc_value;
-	tmp_tb = tstate->exc_traceback;
-	tstate->exc_type = NULL;
-	tstate->exc_value = NULL;
-	tstate->exc_traceback = NULL;
-	Py_XDECREF(tmp_type);
-	Py_XDECREF(tmp_value);
-	Py_XDECREF(tmp_tb);
-	/* For b/w compatibility */
-	PySys_SetObject("exc_type", Py_None);
-	PySys_SetObject("exc_value", Py_None);
-	PySys_SetObject("exc_traceback", Py_None);
-	Py_INCREF(Py_None);
-	return Py_None;
+    PyThreadState *tstate;
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+
+    if (PyErr_WarnPy3k("sys.exc_clear() not supported in 3.x; "
+                       "use except clauses", 1) < 0)
+        return NULL;
+
+    tstate = PyThreadState_GET();
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = NULL;
+    tstate->exc_value = NULL;
+    tstate->exc_traceback = NULL;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+    /* For b/w compatibility */
+    PySys_SetObject("exc_type", Py_None);
+    PySys_SetObject("exc_value", Py_None);
+    PySys_SetObject("exc_traceback", Py_None);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(exc_clear_doc,
@@ -206,12 +206,12 @@ another exception is being handled."
 static PyObject *
 sys_exit(PyObject *self, PyObject *args)
 {
-	PyObject *exit_code = 0;
-	if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))
-		return NULL;
-	/* Raise SystemExit so callers may catch it or clean up. */
-	PyErr_SetObject(PyExc_SystemExit, exit_code);
-	return NULL;
+    PyObject *exit_code = 0;
+    if (!PyArg_UnpackTuple(args, "exit", 0, 1, &exit_code))
+        return NULL;
+    /* Raise SystemExit so callers may catch it or clean up. */
+    PyErr_SetObject(PyExc_SystemExit, exit_code);
+    return NULL;
 }
 
 PyDoc_STRVAR(exit_doc,
@@ -229,7 +229,7 @@ exit status will be one (i.e., failure)."
 static PyObject *
 sys_getdefaultencoding(PyObject *self)
 {
-	return PyString_FromString(PyUnicode_GetDefaultEncoding());
+    return PyString_FromString(PyUnicode_GetDefaultEncoding());
 }
 
 PyDoc_STRVAR(getdefaultencoding_doc,
@@ -242,13 +242,13 @@ implementation."
 static PyObject *
 sys_setdefaultencoding(PyObject *self, PyObject *args)
 {
-	char *encoding;
-	if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding))
-		return NULL;
-	if (PyUnicode_SetDefaultEncoding(encoding))
-	    	return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    char *encoding;
+    if (!PyArg_ParseTuple(args, "s:setdefaultencoding", &encoding))
+        return NULL;
+    if (PyUnicode_SetDefaultEncoding(encoding))
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(setdefaultencoding_doc,
@@ -260,10 +260,10 @@ Set the current default string encoding used by the Unicode implementation."
 static PyObject *
 sys_getfilesystemencoding(PyObject *self)
 {
-	if (Py_FileSystemDefaultEncoding)
-		return PyString_FromString(Py_FileSystemDefaultEncoding);
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (Py_FileSystemDefaultEncoding)
+        return PyString_FromString(Py_FileSystemDefaultEncoding);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(getfilesystemencoding_doc,
@@ -284,116 +284,116 @@ static PyObject *whatstrings[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
 static int
 trace_init(void)
 {
-	static char *whatnames[7] = {"call", "exception", "line", "return",
-					"c_call", "c_exception", "c_return"};
-	PyObject *name;
-	int i;
-	for (i = 0; i < 7; ++i) {
-		if (whatstrings[i] == NULL) {
-			name = PyString_InternFromString(whatnames[i]);
-			if (name == NULL)
-				return -1;
-			whatstrings[i] = name;
-                }
-	}
-	return 0;
+    static char *whatnames[7] = {"call", "exception", "line", "return",
+                                    "c_call", "c_exception", "c_return"};
+    PyObject *name;
+    int i;
+    for (i = 0; i < 7; ++i) {
+        if (whatstrings[i] == NULL) {
+            name = PyString_InternFromString(whatnames[i]);
+            if (name == NULL)
+                return -1;
+            whatstrings[i] = name;
+        }
+    }
+    return 0;
 }
 
 
 static PyObject *
 call_trampoline(PyThreadState *tstate, PyObject* callback,
-		PyFrameObject *frame, int what, PyObject *arg)
+                PyFrameObject *frame, int what, PyObject *arg)
 {
-	PyObject *args = PyTuple_New(3);
-	PyObject *whatstr;
-	PyObject *result;
-
-	if (args == NULL)
-		return NULL;
-	Py_INCREF(frame);
-	whatstr = whatstrings[what];
-	Py_INCREF(whatstr);
-	if (arg == NULL)
-		arg = Py_None;
-	Py_INCREF(arg);
-	PyTuple_SET_ITEM(args, 0, (PyObject *)frame);
-	PyTuple_SET_ITEM(args, 1, whatstr);
-	PyTuple_SET_ITEM(args, 2, arg);
-
-	/* call the Python-level function */
-	PyFrame_FastToLocals(frame);
-	result = PyEval_CallObject(callback, args);
-	PyFrame_LocalsToFast(frame, 1);
-	if (result == NULL)
-		PyTraceBack_Here(frame);
-
-	/* cleanup */
-	Py_DECREF(args);
-	return result;
+    PyObject *args = PyTuple_New(3);
+    PyObject *whatstr;
+    PyObject *result;
+
+    if (args == NULL)
+        return NULL;
+    Py_INCREF(frame);
+    whatstr = whatstrings[what];
+    Py_INCREF(whatstr);
+    if (arg == NULL)
+        arg = Py_None;
+    Py_INCREF(arg);
+    PyTuple_SET_ITEM(args, 0, (PyObject *)frame);
+    PyTuple_SET_ITEM(args, 1, whatstr);
+    PyTuple_SET_ITEM(args, 2, arg);
+
+    /* call the Python-level function */
+    PyFrame_FastToLocals(frame);
+    result = PyEval_CallObject(callback, args);
+    PyFrame_LocalsToFast(frame, 1);
+    if (result == NULL)
+        PyTraceBack_Here(frame);
+
+    /* cleanup */
+    Py_DECREF(args);
+    return result;
 }
 
 static int
 profile_trampoline(PyObject *self, PyFrameObject *frame,
-		   int what, PyObject *arg)
+                   int what, PyObject *arg)
 {
-	PyThreadState *tstate = frame->f_tstate;
-	PyObject *result;
-
-	if (arg == NULL)
-		arg = Py_None;
-	result = call_trampoline(tstate, self, frame, what, arg);
-	if (result == NULL) {
-		PyEval_SetProfile(NULL, NULL);
-		return -1;
-	}
-	Py_DECREF(result);
-	return 0;
+    PyThreadState *tstate = frame->f_tstate;
+    PyObject *result;
+
+    if (arg == NULL)
+        arg = Py_None;
+    result = call_trampoline(tstate, self, frame, what, arg);
+    if (result == NULL) {
+        PyEval_SetProfile(NULL, NULL);
+        return -1;
+    }
+    Py_DECREF(result);
+    return 0;
 }
 
 static int
 trace_trampoline(PyObject *self, PyFrameObject *frame,
-		 int what, PyObject *arg)
+                 int what, PyObject *arg)
 {
-	PyThreadState *tstate = frame->f_tstate;
-	PyObject *callback;
-	PyObject *result;
-
-	if (what == PyTrace_CALL)
-		callback = self;
-	else
-		callback = frame->f_trace;
-	if (callback == NULL)
-		return 0;
-	result = call_trampoline(tstate, callback, frame, what, arg);
-	if (result == NULL) {
-		PyEval_SetTrace(NULL, NULL);
-		Py_XDECREF(frame->f_trace);
-		frame->f_trace = NULL;
-		return -1;
-	}
-	if (result != Py_None) {
-		PyObject *temp = frame->f_trace;
-		frame->f_trace = NULL;
-		Py_XDECREF(temp);
-		frame->f_trace = result;
-	}
-	else {
-		Py_DECREF(result);
-	}
-	return 0;
+    PyThreadState *tstate = frame->f_tstate;
+    PyObject *callback;
+    PyObject *result;
+
+    if (what == PyTrace_CALL)
+        callback = self;
+    else
+        callback = frame->f_trace;
+    if (callback == NULL)
+        return 0;
+    result = call_trampoline(tstate, callback, frame, what, arg);
+    if (result == NULL) {
+        PyEval_SetTrace(NULL, NULL);
+        Py_XDECREF(frame->f_trace);
+        frame->f_trace = NULL;
+        return -1;
+    }
+    if (result != Py_None) {
+        PyObject *temp = frame->f_trace;
+        frame->f_trace = NULL;
+        Py_XDECREF(temp);
+        frame->f_trace = result;
+    }
+    else {
+        Py_DECREF(result);
+    }
+    return 0;
 }
 
 static PyObject *
 sys_settrace(PyObject *self, PyObject *args)
 {
-	if (trace_init() == -1)
-		return NULL;
-	if (args == Py_None)
-		PyEval_SetTrace(NULL, NULL);
-	else
-		PyEval_SetTrace(trace_trampoline, args);
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (trace_init() == -1)
+        return NULL;
+    if (args == Py_None)
+        PyEval_SetTrace(NULL, NULL);
+    else
+        PyEval_SetTrace(trace_trampoline, args);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(settrace_doc,
@@ -406,13 +406,13 @@ function call.  See the debugger chapter in the library manual."
 static PyObject *
 sys_gettrace(PyObject *self, PyObject *args)
 {
-	PyThreadState *tstate = PyThreadState_GET();
-	PyObject *temp = tstate->c_traceobj;
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *temp = tstate->c_traceobj;
 
-	if (temp == NULL)
-		temp = Py_None;
-	Py_INCREF(temp);
-	return temp;
+    if (temp == NULL)
+        temp = Py_None;
+    Py_INCREF(temp);
+    return temp;
 }
 
 PyDoc_STRVAR(gettrace_doc,
@@ -425,14 +425,14 @@ See the debugger chapter in the library manual."
 static PyObject *
 sys_setprofile(PyObject *self, PyObject *args)
 {
-	if (trace_init() == -1)
-		return NULL;
-	if (args == Py_None)
-		PyEval_SetProfile(NULL, NULL);
-	else
-		PyEval_SetProfile(profile_trampoline, args);
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (trace_init() == -1)
+        return NULL;
+    if (args == Py_None)
+        PyEval_SetProfile(NULL, NULL);
+    else
+        PyEval_SetProfile(profile_trampoline, args);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(setprofile_doc,
@@ -445,13 +445,13 @@ and return.  See the profiler chapter in the library manual."
 static PyObject *
 sys_getprofile(PyObject *self, PyObject *args)
 {
-	PyThreadState *tstate = PyThreadState_GET();
-	PyObject *temp = tstate->c_profileobj;
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject *temp = tstate->c_profileobj;
 
-	if (temp == NULL)
-		temp = Py_None;
-	Py_INCREF(temp);
-	return temp;
+    if (temp == NULL)
+        temp = Py_None;
+    Py_INCREF(temp);
+    return temp;
 }
 
 PyDoc_STRVAR(getprofile_doc,
@@ -464,10 +464,10 @@ See the profiler chapter in the library manual."
 static PyObject *
 sys_setcheckinterval(PyObject *self, PyObject *args)
 {
-	if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval))
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyArg_ParseTuple(args, "i:setcheckinterval", &_Py_CheckInterval))
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(setcheckinterval_doc,
@@ -480,7 +480,7 @@ n instructions.  This also affects how often thread switches occur."
 static PyObject *
 sys_getcheckinterval(PyObject *self, PyObject *args)
 {
-	return PyInt_FromLong(_Py_CheckInterval);
+    return PyInt_FromLong(_Py_CheckInterval);
 }
 
 PyDoc_STRVAR(getcheckinterval_doc,
@@ -491,17 +491,17 @@ PyDoc_STRVAR(getcheckinterval_doc,
 static PyObject *
 sys_settscdump(PyObject *self, PyObject *args)
 {
-	int bool;
-	PyThreadState *tstate = PyThreadState_Get();
-
-	if (!PyArg_ParseTuple(args, "i:settscdump", &bool))
-		return NULL;
-	if (bool)
-		tstate->interp->tscdump = 1;
-	else
-		tstate->interp->tscdump = 0;
-	Py_INCREF(Py_None);
-	return Py_None;
+    int bool;
+    PyThreadState *tstate = PyThreadState_Get();
+
+    if (!PyArg_ParseTuple(args, "i:settscdump", &bool))
+        return NULL;
+    if (bool)
+        tstate->interp->tscdump = 1;
+    else
+        tstate->interp->tscdump = 0;
+    Py_INCREF(Py_None);
+    return Py_None;
 
 }
 
@@ -517,17 +517,17 @@ processor's time-stamp counter."
 static PyObject *
 sys_setrecursionlimit(PyObject *self, PyObject *args)
 {
-	int new_limit;
-	if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))
-		return NULL;
-	if (new_limit <= 0) {
-		PyErr_SetString(PyExc_ValueError,
-				"recursion limit must be positive");
-		return NULL;
-	}
-	Py_SetRecursionLimit(new_limit);
-	Py_INCREF(Py_None);
-	return Py_None;
+    int new_limit;
+    if (!PyArg_ParseTuple(args, "i:setrecursionlimit", &new_limit))
+        return NULL;
+    if (new_limit <= 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "recursion limit must be positive");
+        return NULL;
+    }
+    Py_SetRecursionLimit(new_limit);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(setrecursionlimit_doc,
@@ -542,7 +542,7 @@ dependent."
 static PyObject *
 sys_getrecursionlimit(PyObject *self)
 {
-	return PyInt_FromLong(Py_GetRecursionLimit());
+    return PyInt_FromLong(Py_GetRecursionLimit());
 }
 
 PyDoc_STRVAR(getrecursionlimit_doc,
@@ -570,52 +570,52 @@ controller, 3 for a server."
 static PyTypeObject WindowsVersionType = {0, 0, 0, 0, 0, 0};
 
 static PyStructSequence_Field windows_version_fields[] = {
-	{"major", "Major version number"},
-	{"minor", "Minor version number"},
-	{"build", "Build number"},
-	{"platform", "Operating system platform"},
-	{"service_pack", "Latest Service Pack installed on the system"},
-	{"service_pack_major", "Service Pack major version number"},
-	{"service_pack_minor", "Service Pack minor version number"},
-	{"suite_mask", "Bit mask identifying available product suites"},
-	{"product_type", "System product type"},
-	{0}
+    {"major", "Major version number"},
+    {"minor", "Minor version number"},
+    {"build", "Build number"},
+    {"platform", "Operating system platform"},
+    {"service_pack", "Latest Service Pack installed on the system"},
+    {"service_pack_major", "Service Pack major version number"},
+    {"service_pack_minor", "Service Pack minor version number"},
+    {"suite_mask", "Bit mask identifying available product suites"},
+    {"product_type", "System product type"},
+    {0}
 };
 
 static PyStructSequence_Desc windows_version_desc = {
-	"sys.getwindowsversion",  /* name */
-	getwindowsversion_doc,    /* doc */
-	windows_version_fields,   /* fields */
-	5                         /* For backward compatibility,
-                                     only the first 5 items are accessible
-                                     via indexing, the rest are name only */
+    "sys.getwindowsversion",  /* name */
+    getwindowsversion_doc,    /* doc */
+    windows_version_fields,   /* fields */
+    5                         /* For backward compatibility,
+                                 only the first 5 items are accessible
+                                 via indexing, the rest are name only */
 };
 
 static PyObject *
 sys_getwindowsversion(PyObject *self)
 {
-	PyObject *version;
-	int pos = 0;
-	OSVERSIONINFOEX ver;
-	ver.dwOSVersionInfoSize = sizeof(ver);
-	if (!GetVersionEx((OSVERSIONINFO*) &ver))
-		return PyErr_SetFromWindowsErr(0);
-
-	version = PyStructSequence_New(&WindowsVersionType);
-	if (version == NULL)
-		return NULL;
-
-	PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMajorVersion));
-	PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMinorVersion));
-	PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwBuildNumber));
-	PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwPlatformId));
-	PyStructSequence_SET_ITEM(version, pos++, PyString_FromString(ver.szCSDVersion));
-	PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMajor));
-	PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMinor));
-	PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wSuiteMask));
-	PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wProductType));
-
-	return version;
+    PyObject *version;
+    int pos = 0;
+    OSVERSIONINFOEX ver;
+    ver.dwOSVersionInfoSize = sizeof(ver);
+    if (!GetVersionEx((OSVERSIONINFO*) &ver))
+        return PyErr_SetFromWindowsErr(0);
+
+    version = PyStructSequence_New(&WindowsVersionType);
+    if (version == NULL)
+        return NULL;
+
+    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMajorVersion));
+    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwMinorVersion));
+    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwBuildNumber));
+    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.dwPlatformId));
+    PyStructSequence_SET_ITEM(version, pos++, PyString_FromString(ver.szCSDVersion));
+    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMajor));
+    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wServicePackMinor));
+    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wSuiteMask));
+    PyStructSequence_SET_ITEM(version, pos++, PyInt_FromLong(ver.wProductType));
+
+    return version;
 }
 
 #endif /* MS_WINDOWS */
@@ -624,15 +624,15 @@ sys_getwindowsversion(PyObject *self)
 static PyObject *
 sys_setdlopenflags(PyObject *self, PyObject *args)
 {
-	int new_val;
-        PyThreadState *tstate = PyThreadState_GET();
-	if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
-		return NULL;
-        if (!tstate)
-		return NULL;
-        tstate->interp->dlopenflags = new_val;
-	Py_INCREF(Py_None);
-	return Py_None;
+    int new_val;
+    PyThreadState *tstate = PyThreadState_GET();
+    if (!PyArg_ParseTuple(args, "i:setdlopenflags", &new_val))
+        return NULL;
+    if (!tstate)
+        return NULL;
+    tstate->interp->dlopenflags = new_val;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(setdlopenflags_doc,
@@ -650,10 +650,10 @@ h2py script.");
 static PyObject *
 sys_getdlopenflags(PyObject *self, PyObject *args)
 {
-        PyThreadState *tstate = PyThreadState_GET();
-        if (!tstate)
-		return NULL;
-        return PyInt_FromLong(tstate->interp->dlopenflags);
+    PyThreadState *tstate = PyThreadState_GET();
+    if (!tstate)
+        return NULL;
+    return PyInt_FromLong(tstate->interp->dlopenflags);
 }
 
 PyDoc_STRVAR(getdlopenflags_doc,
@@ -662,7 +662,7 @@ PyDoc_STRVAR(getdlopenflags_doc,
 Return the current value of the flags that are used for dlopen calls.\n\
 The flag constants are defined in the ctypes and DLFCN modules.");
 
-#endif	/* HAVE_DLOPEN */
+#endif  /* HAVE_DLOPEN */
 
 #ifdef USE_MALLOPT
 /* Link with -lmalloc (or -lmpc) on an SGI */
@@ -671,75 +671,75 @@ The flag constants are defined in the ctypes and DLFCN modules.");
 static PyObject *
 sys_mdebug(PyObject *self, PyObject *args)
 {
-	int flag;
-	if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
-		return NULL;
-	mallopt(M_DEBUG, flag);
-	Py_INCREF(Py_None);
-	return Py_None;
+    int flag;
+    if (!PyArg_ParseTuple(args, "i:mdebug", &flag))
+        return NULL;
+    mallopt(M_DEBUG, flag);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 #endif /* USE_MALLOPT */
 
 static PyObject *
 sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
 {
-	PyObject *res = NULL;
-	static PyObject *str__sizeof__ = NULL, *gc_head_size = NULL;
-	static char *kwlist[] = {"object", "default", 0};
-	PyObject *o, *dflt = NULL;
-
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof",
-					 kwlist, &o, &dflt))
-		return NULL;
-
-        /* Initialize static variable for GC head size */
-	if (gc_head_size == NULL) {
-		gc_head_size = PyInt_FromSsize_t(sizeof(PyGC_Head));
-		if (gc_head_size == NULL)
-			return NULL;
-	}
-
-	/* Make sure the type is initialized. float gets initialized late */
-	if (PyType_Ready(Py_TYPE(o)) < 0)
-		return NULL;
-
-	/* Instance of old-style class */
-	if (PyInstance_Check(o))
-		res = PyInt_FromSsize_t(PyInstance_Type.tp_basicsize);
-	/* all other objects */
-	else {
-		PyObject *method = _PyObject_LookupSpecial(o, "__sizeof__",
-							   &str__sizeof__);
-		if (method == NULL) {
-			if (!PyErr_Occurred())
-				PyErr_Format(PyExc_TypeError,
-					     "Type %.100s doesn't define __sizeof__",
-					     Py_TYPE(o)->tp_name);
-		}
-		else {
-			res = PyObject_CallFunctionObjArgs(method, NULL);
-			Py_DECREF(method);
-		}
-	}
-	
-	/* Has a default value been given? */
-	if ((res == NULL) && (dflt != NULL) &&
-	    PyErr_ExceptionMatches(PyExc_TypeError))
-	{
-		PyErr_Clear();
-		Py_INCREF(dflt);
-		return dflt;
-	}
-	else if (res == NULL)
-		return res;
-
-	/* add gc_head size */
-	if (PyObject_IS_GC(o)) {
-		PyObject *tmp = res;
-		res = PyNumber_Add(tmp, gc_head_size);
-		Py_DECREF(tmp);
-	}
-	return res;
+    PyObject *res = NULL;
+    static PyObject *str__sizeof__ = NULL, *gc_head_size = NULL;
+    static char *kwlist[] = {"object", "default", 0};
+    PyObject *o, *dflt = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:getsizeof",
+                                     kwlist, &o, &dflt))
+        return NULL;
+
+    /* Initialize static variable for GC head size */
+    if (gc_head_size == NULL) {
+        gc_head_size = PyInt_FromSsize_t(sizeof(PyGC_Head));
+        if (gc_head_size == NULL)
+            return NULL;
+    }
+
+    /* Make sure the type is initialized. float gets initialized late */
+    if (PyType_Ready(Py_TYPE(o)) < 0)
+        return NULL;
+
+    /* Instance of old-style class */
+    if (PyInstance_Check(o))
+        res = PyInt_FromSsize_t(PyInstance_Type.tp_basicsize);
+    /* all other objects */
+    else {
+        PyObject *method = _PyObject_LookupSpecial(o, "__sizeof__",
+                                                   &str__sizeof__);
+        if (method == NULL) {
+            if (!PyErr_Occurred())
+                PyErr_Format(PyExc_TypeError,
+                             "Type %.100s doesn't define __sizeof__",
+                             Py_TYPE(o)->tp_name);
+        }
+        else {
+            res = PyObject_CallFunctionObjArgs(method, NULL);
+            Py_DECREF(method);
+        }
+    }
+
+    /* Has a default value been given? */
+    if ((res == NULL) && (dflt != NULL) &&
+        PyErr_ExceptionMatches(PyExc_TypeError))
+    {
+        PyErr_Clear();
+        Py_INCREF(dflt);
+        return dflt;
+    }
+    else if (res == NULL)
+        return res;
+
+    /* add gc_head size */
+    if (PyObject_IS_GC(o)) {
+        PyObject *tmp = res;
+        res = PyNumber_Add(tmp, gc_head_size);
+        Py_DECREF(tmp);
+    }
+    return res;
 }
 
 PyDoc_STRVAR(getsizeof_doc,
@@ -750,14 +750,14 @@ Return the size of object in bytes.");
 static PyObject *
 sys_getrefcount(PyObject *self, PyObject *arg)
 {
-	return PyInt_FromSsize_t(arg->ob_refcnt);
+    return PyInt_FromSsize_t(arg->ob_refcnt);
 }
 
 #ifdef Py_REF_DEBUG
 static PyObject *
 sys_gettotalrefcount(PyObject *self)
 {
-	return PyInt_FromSsize_t(_Py_GetRefTotal());
+    return PyInt_FromSsize_t(_Py_GetRefTotal());
 }
 #endif /* Py_REF_DEBUG */
 
@@ -773,9 +773,9 @@ reference as an argument to getrefcount()."
 static PyObject *
 sys_getcounts(PyObject *self)
 {
-	extern PyObject *get_counts(void);
+    extern PyObject *get_counts(void);
 
-	return get_counts();
+    return get_counts();
 }
 #endif
 
@@ -794,23 +794,23 @@ purposes only."
 static PyObject *
 sys_getframe(PyObject *self, PyObject *args)
 {
-	PyFrameObject *f = PyThreadState_GET()->frame;
-	int depth = -1;
-
-	if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
-		return NULL;
-
-	while (depth > 0 && f != NULL) {
-		f = f->f_back;
-		--depth;
-	}
-	if (f == NULL) {
-		PyErr_SetString(PyExc_ValueError,
-				"call stack is not deep enough");
-		return NULL;
-	}
-	Py_INCREF(f);
-	return (PyObject*)f;
+    PyFrameObject *f = PyThreadState_GET()->frame;
+    int depth = -1;
+
+    if (!PyArg_ParseTuple(args, "|i:_getframe", &depth))
+        return NULL;
+
+    while (depth > 0 && f != NULL) {
+        f = f->f_back;
+        --depth;
+    }
+    if (f == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+                        "call stack is not deep enough");
+        return NULL;
+    }
+    Py_INCREF(f);
+    return (PyObject*)f;
 }
 
 PyDoc_STRVAR(current_frames_doc,
@@ -825,7 +825,7 @@ This function should be used for specialized purposes only."
 static PyObject *
 sys_current_frames(PyObject *self, PyObject *noargs)
 {
-	return _PyThread_CurrentFrames();
+    return _PyThread_CurrentFrames();
 }
 
 PyDoc_STRVAR(call_tracing_doc,
@@ -839,10 +839,10 @@ a debugger from a checkpoint, to recursively debug some other code."
 static PyObject *
 sys_call_tracing(PyObject *self, PyObject *args)
 {
-	PyObject *func, *funcargs;
-	if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
-		return NULL;
-	return _PyEval_CallTracing(func, funcargs);
+    PyObject *func, *funcargs;
+    if (!PyArg_ParseTuple(args, "OO!:call_tracing", &func, &PyTuple_Type, &funcargs))
+        return NULL;
+    return _PyEval_CallTracing(func, funcargs);
 }
 
 PyDoc_STRVAR(callstats_doc,
@@ -889,8 +889,8 @@ extern PyObject *_Py_GetDXProfile(PyObject *,  PyObject *);
 static PyObject *
 sys_clear_type_cache(PyObject* self, PyObject* args)
 {
-	PyType_ClearCache();
-	Py_RETURN_NONE;
+    PyType_ClearCache();
+    Py_RETURN_NONE;
 }
 
 PyDoc_STRVAR(sys_clear_type_cache__doc__,
@@ -899,105 +899,105 @@ Clear the internal type lookup cache.");
 
 
 static PyMethodDef sys_methods[] = {
-	/* Might as well keep this in alphabetic order */
-	{"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
-	 callstats_doc},
-	{"_clear_type_cache",	sys_clear_type_cache,	  METH_NOARGS,
-	 sys_clear_type_cache__doc__},
-	{"_current_frames", sys_current_frames, METH_NOARGS,
-	 current_frames_doc},
-	{"displayhook",	sys_displayhook, METH_O, displayhook_doc},
-	{"exc_info",	sys_exc_info, METH_NOARGS, exc_info_doc},
-	{"exc_clear",	sys_exc_clear, METH_NOARGS, exc_clear_doc},
-	{"excepthook",	sys_excepthook, METH_VARARGS, excepthook_doc},
-	{"exit",	sys_exit, METH_VARARGS, exit_doc},
+    /* Might as well keep this in alphabetic order */
+    {"callstats", (PyCFunction)PyEval_GetCallStats, METH_NOARGS,
+     callstats_doc},
+    {"_clear_type_cache",       sys_clear_type_cache,     METH_NOARGS,
+     sys_clear_type_cache__doc__},
+    {"_current_frames", sys_current_frames, METH_NOARGS,
+     current_frames_doc},
+    {"displayhook",     sys_displayhook, METH_O, displayhook_doc},
+    {"exc_info",        sys_exc_info, METH_NOARGS, exc_info_doc},
+    {"exc_clear",       sys_exc_clear, METH_NOARGS, exc_clear_doc},
+    {"excepthook",      sys_excepthook, METH_VARARGS, excepthook_doc},
+    {"exit",            sys_exit, METH_VARARGS, exit_doc},
 #ifdef Py_USING_UNICODE
-	{"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,
-	 METH_NOARGS, getdefaultencoding_doc},
+    {"getdefaultencoding", (PyCFunction)sys_getdefaultencoding,
+     METH_NOARGS, getdefaultencoding_doc},
 #endif
 #ifdef HAVE_DLOPEN
-	{"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
-	 getdlopenflags_doc},
+    {"getdlopenflags", (PyCFunction)sys_getdlopenflags, METH_NOARGS,
+     getdlopenflags_doc},
 #endif
 #ifdef COUNT_ALLOCS
-	{"getcounts",	(PyCFunction)sys_getcounts, METH_NOARGS},
+    {"getcounts",       (PyCFunction)sys_getcounts, METH_NOARGS},
 #endif
 #ifdef DYNAMIC_EXECUTION_PROFILE
-	{"getdxp",	_Py_GetDXProfile, METH_VARARGS},
+    {"getdxp",          _Py_GetDXProfile, METH_VARARGS},
 #endif
 #ifdef Py_USING_UNICODE
-	{"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
-	 METH_NOARGS, getfilesystemencoding_doc},
+    {"getfilesystemencoding", (PyCFunction)sys_getfilesystemencoding,
+     METH_NOARGS, getfilesystemencoding_doc},
 #endif
 #ifdef Py_TRACE_REFS
-	{"getobjects",	_Py_GetObjects, METH_VARARGS},
+    {"getobjects",      _Py_GetObjects, METH_VARARGS},
 #endif
 #ifdef Py_REF_DEBUG
-	{"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
+    {"gettotalrefcount", (PyCFunction)sys_gettotalrefcount, METH_NOARGS},
 #endif
-	{"getrefcount",	(PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
-	{"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
-	 getrecursionlimit_doc},
-	{"getsizeof",   (PyCFunction)sys_getsizeof,
-	 METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
-	{"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
+    {"getrefcount",     (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
+    {"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
+     getrecursionlimit_doc},
+    {"getsizeof",   (PyCFunction)sys_getsizeof,
+     METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
+    {"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
 #ifdef MS_WINDOWS
-	{"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
-	 getwindowsversion_doc},
+    {"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
+     getwindowsversion_doc},
 #endif /* MS_WINDOWS */
 #ifdef USE_MALLOPT
-	{"mdebug",	sys_mdebug, METH_VARARGS},
+    {"mdebug",          sys_mdebug, METH_VARARGS},
 #endif
 #ifdef Py_USING_UNICODE
-	{"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS,
-	 setdefaultencoding_doc},
+    {"setdefaultencoding", sys_setdefaultencoding, METH_VARARGS,
+     setdefaultencoding_doc},
 #endif
-	{"setcheckinterval",	sys_setcheckinterval, METH_VARARGS,
-	 setcheckinterval_doc},
-	{"getcheckinterval",	sys_getcheckinterval, METH_NOARGS,
-	 getcheckinterval_doc},
+    {"setcheckinterval",        sys_setcheckinterval, METH_VARARGS,
+     setcheckinterval_doc},
+    {"getcheckinterval",        sys_getcheckinterval, METH_NOARGS,
+     getcheckinterval_doc},
 #ifdef HAVE_DLOPEN
-	{"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
-	 setdlopenflags_doc},
+    {"setdlopenflags", sys_setdlopenflags, METH_VARARGS,
+     setdlopenflags_doc},
 #endif
-	{"setprofile",	sys_setprofile, METH_O, setprofile_doc},
-	{"getprofile",	sys_getprofile, METH_NOARGS, getprofile_doc},
-	{"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
-	 setrecursionlimit_doc},
+    {"setprofile",      sys_setprofile, METH_O, setprofile_doc},
+    {"getprofile",      sys_getprofile, METH_NOARGS, getprofile_doc},
+    {"setrecursionlimit", sys_setrecursionlimit, METH_VARARGS,
+     setrecursionlimit_doc},
 #ifdef WITH_TSC
-	{"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
+    {"settscdump", sys_settscdump, METH_VARARGS, settscdump_doc},
 #endif
-	{"settrace",	sys_settrace, METH_O, settrace_doc},
-	{"gettrace",	sys_gettrace, METH_NOARGS, gettrace_doc},
-	{"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
-	{NULL,		NULL}		/* sentinel */
+    {"settrace",        sys_settrace, METH_O, settrace_doc},
+    {"gettrace",        sys_gettrace, METH_NOARGS, gettrace_doc},
+    {"call_tracing", sys_call_tracing, METH_VARARGS, call_tracing_doc},
+    {NULL,              NULL}           /* sentinel */
 };
 
 static PyObject *
 list_builtin_module_names(void)
 {
-	PyObject *list = PyList_New(0);
-	int i;
-	if (list == NULL)
-		return NULL;
-	for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
-		PyObject *name = PyString_FromString(
-			PyImport_Inittab[i].name);
-		if (name == NULL)
-			break;
-		PyList_Append(list, name);
-		Py_DECREF(name);
-	}
-	if (PyList_Sort(list) != 0) {
-		Py_DECREF(list);
-		list = NULL;
-	}
-	if (list) {
-		PyObject *v = PyList_AsTuple(list);
-		Py_DECREF(list);
-		list = v;
-	}
-	return list;
+    PyObject *list = PyList_New(0);
+    int i;
+    if (list == NULL)
+        return NULL;
+    for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
+        PyObject *name = PyString_FromString(
+            PyImport_Inittab[i].name);
+        if (name == NULL)
+            break;
+        PyList_Append(list, name);
+        Py_DECREF(name);
+    }
+    if (PyList_Sort(list) != 0) {
+        Py_DECREF(list);
+        list = NULL;
+    }
+    if (list) {
+        PyObject *v = PyList_AsTuple(list);
+        Py_DECREF(list);
+        list = v;
+    }
+    return list;
 }
 
 static PyObject *warnoptions = NULL;
@@ -1005,27 +1005,27 @@ static PyObject *warnoptions = NULL;
 void
 PySys_ResetWarnOptions(void)
 {
-	if (warnoptions == NULL || !PyList_Check(warnoptions))
-		return;
-	PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
+    if (warnoptions == NULL || !PyList_Check(warnoptions))
+        return;
+    PyList_SetSlice(warnoptions, 0, PyList_GET_SIZE(warnoptions), NULL);
 }
 
 void
 PySys_AddWarnOption(char *s)
 {
-	PyObject *str;
-
-	if (warnoptions == NULL || !PyList_Check(warnoptions)) {
-		Py_XDECREF(warnoptions);
-		warnoptions = PyList_New(0);
-		if (warnoptions == NULL)
-			return;
-	}
-	str = PyString_FromString(s);
-	if (str != NULL) {
-		PyList_Append(warnoptions, str);
-		Py_DECREF(str);
-	}
+    PyObject *str;
+
+    if (warnoptions == NULL || !PyList_Check(warnoptions)) {
+        Py_XDECREF(warnoptions);
+        warnoptions = PyList_New(0);
+        if (warnoptions == NULL)
+            return;
+    }
+    str = PyString_FromString(s);
+    if (str != NULL) {
+        PyList_Append(warnoptions, str);
+        Py_DECREF(str);
+    }
 }
 
 int
@@ -1154,69 +1154,69 @@ static const char *svn_revision;
 static void
 svnversion_init(void)
 {
-	const char *python, *br_start, *br_end, *br_end2, *svnversion;
-	Py_ssize_t len;
-	int istag;
-
-	if (svn_initialized)
-		return;
-
-	python = strstr(headurl, "/python/");
-	if (!python) {
-		/* XXX quick hack to get bzr working */
-		*patchlevel_revision = '\0';
-		strcpy(branch, "");
-		strcpy(shortbranch, "unknown");
-		svn_revision = "";
-		return;
-		/* Py_FatalError("subversion keywords missing"); */
-	}
-
-	br_start = python + 8;
-	br_end = strchr(br_start, '/');
-	assert(br_end);
-
-	/* Works even for trunk,
-	   as we are in trunk/Python/sysmodule.c */
-	br_end2 = strchr(br_end+1, '/');
-
-	istag = strncmp(br_start, "tags", 4) == 0;
-	if (strncmp(br_start, "trunk", 5) == 0) {
-		strcpy(branch, "trunk");
-		strcpy(shortbranch, "trunk");
-
-	}
-	else if (istag || strncmp(br_start, "branches", 8) == 0) {
-		len = br_end2 - br_start;
-		strncpy(branch, br_start, len);
-		branch[len] = '\0';
-
-		len = br_end2 - (br_end + 1);
-		strncpy(shortbranch, br_end + 1, len);
-		shortbranch[len] = '\0';
-	}
-	else {
-		Py_FatalError("bad HeadURL"); 
-		return;
-	}
-
-
-	svnversion = _Py_svnversion();
-	if (strcmp(svnversion, "Unversioned directory") != 0 && strcmp(svnversion, "exported") != 0)
-		svn_revision = svnversion;
-	else if (istag) {
-		len = strlen(_patchlevel_revision);
-		assert(len >= 13);
-		assert(len < (sizeof(patchlevel_revision) + 13));
-		strncpy(patchlevel_revision, _patchlevel_revision + 11,
-			len - 13);
-		patchlevel_revision[len - 13] = '\0';
-		svn_revision = patchlevel_revision;
-	}
-	else
-		svn_revision = "";
-
-	svn_initialized = 1;
+    const char *python, *br_start, *br_end, *br_end2, *svnversion;
+    Py_ssize_t len;
+    int istag;
+
+    if (svn_initialized)
+        return;
+
+    python = strstr(headurl, "/python/");
+    if (!python) {
+        /* XXX quick hack to get bzr working */
+        *patchlevel_revision = '\0';
+        strcpy(branch, "");
+        strcpy(shortbranch, "unknown");
+        svn_revision = "";
+        return;
+        /* Py_FatalError("subversion keywords missing"); */
+    }
+
+    br_start = python + 8;
+    br_end = strchr(br_start, '/');
+    assert(br_end);
+
+    /* Works even for trunk,
+       as we are in trunk/Python/sysmodule.c */
+    br_end2 = strchr(br_end+1, '/');
+
+    istag = strncmp(br_start, "tags", 4) == 0;
+    if (strncmp(br_start, "trunk", 5) == 0) {
+        strcpy(branch, "trunk");
+        strcpy(shortbranch, "trunk");
+
+    }
+    else if (istag || strncmp(br_start, "branches", 8) == 0) {
+        len = br_end2 - br_start;
+        strncpy(branch, br_start, len);
+        branch[len] = '\0';
+
+        len = br_end2 - (br_end + 1);
+        strncpy(shortbranch, br_end + 1, len);
+        shortbranch[len] = '\0';
+    }
+    else {
+        Py_FatalError("bad HeadURL");
+        return;
+    }
+
+
+    svnversion = _Py_svnversion();
+    if (strcmp(svnversion, "Unversioned directory") != 0 && strcmp(svnversion, "exported") != 0)
+        svn_revision = svnversion;
+    else if (istag) {
+        len = strlen(_patchlevel_revision);
+        assert(len >= 13);
+        assert(len < (sizeof(patchlevel_revision) + 13));
+        strncpy(patchlevel_revision, _patchlevel_revision + 11,
+            len - 13);
+        patchlevel_revision[len - 13] = '\0';
+        svn_revision = patchlevel_revision;
+    }
+    else
+        svn_revision = "";
+
+    svn_initialized = 1;
 }
 
 /* Return svnversion output if available.
@@ -1225,15 +1225,15 @@ svnversion_init(void)
 const char*
 Py_SubversionRevision()
 {
-	svnversion_init();
-	return svn_revision;
+    svnversion_init();
+    return svn_revision;
 }
 
 const char*
 Py_SubversionShortBranch()
 {
-	svnversion_init();
-	return shortbranch;
+    svnversion_init();
+    return shortbranch;
 }
 
 
@@ -1245,79 +1245,79 @@ Flags provided through command line arguments or environment vars.");
 static PyTypeObject FlagsType = {0, 0, 0, 0, 0, 0};
 
 static PyStructSequence_Field flags_fields[] = {
-	{"debug",		"-d"},
-	{"py3k_warning",	"-3"},
-	{"division_warning",	"-Q"},
-	{"division_new",	"-Qnew"},
-	{"inspect",		"-i"},
-	{"interactive",		"-i"},
-	{"optimize",		"-O or -OO"},
-	{"dont_write_bytecode",	"-B"},
-	{"no_user_site",	"-s"},
-	{"no_site",		"-S"},
-	{"ignore_environment",	"-E"},
-	{"tabcheck",		"-t or -tt"},
-	{"verbose",		"-v"},
+    {"debug",                   "-d"},
+    {"py3k_warning",            "-3"},
+    {"division_warning",        "-Q"},
+    {"division_new",            "-Qnew"},
+    {"inspect",                 "-i"},
+    {"interactive",             "-i"},
+    {"optimize",                "-O or -OO"},
+    {"dont_write_bytecode",     "-B"},
+    {"no_user_site",            "-s"},
+    {"no_site",                 "-S"},
+    {"ignore_environment",      "-E"},
+    {"tabcheck",                "-t or -tt"},
+    {"verbose",                 "-v"},
 #ifdef RISCOS
-	{"riscos_wimp",		"???"},
+    {"riscos_wimp",             "???"},
 #endif
-	/* {"unbuffered",		"-u"}, */
-	{"unicode",		"-U"},
-	/* {"skip_first",		"-x"}, */
-	{"bytes_warning", "-b"},
-	{0}
+    /* {"unbuffered",                   "-u"}, */
+    {"unicode",                 "-U"},
+    /* {"skip_first",                   "-x"}, */
+    {"bytes_warning", "-b"},
+    {0}
 };
 
 static PyStructSequence_Desc flags_desc = {
-	"sys.flags",	/* name */
-	flags__doc__,	/* doc */
-	flags_fields,	/* fields */
+    "sys.flags",        /* name */
+    flags__doc__,       /* doc */
+    flags_fields,       /* fields */
 #ifdef RISCOS
-	16
+    16
 #else
-	15
+    15
 #endif
 };
 
 static PyObject*
 make_flags(void)
 {
-	int pos = 0;
-	PyObject *seq;
+    int pos = 0;
+    PyObject *seq;
 
-	seq = PyStructSequence_New(&FlagsType);
-	if (seq == NULL)
-		return NULL;
+    seq = PyStructSequence_New(&FlagsType);
+    if (seq == NULL)
+        return NULL;
 
 #define SetFlag(flag) \
-	PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag))
-
-	SetFlag(Py_DebugFlag);
-	SetFlag(Py_Py3kWarningFlag);
-	SetFlag(Py_DivisionWarningFlag);
-	SetFlag(_Py_QnewFlag);
-	SetFlag(Py_InspectFlag);
-	SetFlag(Py_InteractiveFlag);
-	SetFlag(Py_OptimizeFlag);
-	SetFlag(Py_DontWriteBytecodeFlag);
-	SetFlag(Py_NoUserSiteDirectory);
-	SetFlag(Py_NoSiteFlag);
-	SetFlag(Py_IgnoreEnvironmentFlag);
-	SetFlag(Py_TabcheckFlag);
-	SetFlag(Py_VerboseFlag);
+    PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag))
+
+    SetFlag(Py_DebugFlag);
+    SetFlag(Py_Py3kWarningFlag);
+    SetFlag(Py_DivisionWarningFlag);
+    SetFlag(_Py_QnewFlag);
+    SetFlag(Py_InspectFlag);
+    SetFlag(Py_InteractiveFlag);
+    SetFlag(Py_OptimizeFlag);
+    SetFlag(Py_DontWriteBytecodeFlag);
+    SetFlag(Py_NoUserSiteDirectory);
+    SetFlag(Py_NoSiteFlag);
+    SetFlag(Py_IgnoreEnvironmentFlag);
+    SetFlag(Py_TabcheckFlag);
+    SetFlag(Py_VerboseFlag);
 #ifdef RISCOS
-	SetFlag(Py_RISCOSWimpFlag);
+    SetFlag(Py_RISCOSWimpFlag);
 #endif
-	/* SetFlag(saw_unbuffered_flag); */
-	SetFlag(Py_UnicodeFlag);
-	/* SetFlag(skipfirstline); */
+    /* SetFlag(saw_unbuffered_flag); */
+    SetFlag(Py_UnicodeFlag);
+    /* SetFlag(skipfirstline); */
     SetFlag(Py_BytesWarningFlag);
 #undef SetFlag
 
-	if (PyErr_Occurred()) {
-		return NULL;
-	}
-	return seq;
+    if (PyErr_Occurred()) {
+        return NULL;
+    }
+    return seq;
 }
 
 PyDoc_STRVAR(version_info__doc__,
@@ -1328,428 +1328,428 @@ Version information as a named tuple.");
 static PyTypeObject VersionInfoType = {0, 0, 0, 0, 0, 0};
 
 static PyStructSequence_Field version_info_fields[] = {
-	{"major", "Major release number"},
-	{"minor", "Minor release number"},
-	{"micro", "Patch release number"},
-	{"releaselevel", "'alpha', 'beta', 'candidate', or 'release'"},
-	{"serial", "Serial release number"},
-	{0}
+    {"major", "Major release number"},
+    {"minor", "Minor release number"},
+    {"micro", "Patch release number"},
+    {"releaselevel", "'alpha', 'beta', 'candidate', or 'release'"},
+    {"serial", "Serial release number"},
+    {0}
 };
 
 static PyStructSequence_Desc version_info_desc = {
-	"sys.version_info",     /* name */
-	version_info__doc__,    /* doc */
-	version_info_fields,    /* fields */
-	5
+    "sys.version_info",     /* name */
+    version_info__doc__,    /* doc */
+    version_info_fields,    /* fields */
+    5
 };
 
 static PyObject *
 make_version_info(void)
 {
-	PyObject *version_info;
-	char *s;
-	int pos = 0;
-
-	version_info = PyStructSequence_New(&VersionInfoType);
-	if (version_info == NULL) {
-		return NULL;
-	}
-
-	/*
-	 * These release level checks are mutually exclusive and cover
-	 * the field, so don't get too fancy with the pre-processor!
-	 */
+    PyObject *version_info;
+    char *s;
+    int pos = 0;
+
+    version_info = PyStructSequence_New(&VersionInfoType);
+    if (version_info == NULL) {
+        return NULL;
+    }
+
+    /*
+     * These release level checks are mutually exclusive and cover
+     * the field, so don't get too fancy with the pre-processor!
+     */
 #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA
-	s = "alpha";
+    s = "alpha";
 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA
-	s = "beta";
+    s = "beta";
 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA
-	s = "candidate";
+    s = "candidate";
 #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL
-	s = "final";
+    s = "final";
 #endif
 
 #define SetIntItem(flag) \
-	PyStructSequence_SET_ITEM(version_info, pos++, PyInt_FromLong(flag))
+    PyStructSequence_SET_ITEM(version_info, pos++, PyInt_FromLong(flag))
 #define SetStrItem(flag) \
-	PyStructSequence_SET_ITEM(version_info, pos++, PyString_FromString(flag))
+    PyStructSequence_SET_ITEM(version_info, pos++, PyString_FromString(flag))
 
-	SetIntItem(PY_MAJOR_VERSION);
-	SetIntItem(PY_MINOR_VERSION);
-	SetIntItem(PY_MICRO_VERSION);
-	SetStrItem(s);
-	SetIntItem(PY_RELEASE_SERIAL);
+    SetIntItem(PY_MAJOR_VERSION);
+    SetIntItem(PY_MINOR_VERSION);
+    SetIntItem(PY_MICRO_VERSION);
+    SetStrItem(s);
+    SetIntItem(PY_RELEASE_SERIAL);
 #undef SetIntItem
 #undef SetStrItem
 
-	if (PyErr_Occurred()) {
-		Py_CLEAR(version_info);
-		return NULL;
-	}
-	return version_info;
+    if (PyErr_Occurred()) {
+        Py_CLEAR(version_info);
+        return NULL;
+    }
+    return version_info;
 }
 
 PyObject *
 _PySys_Init(void)
 {
-	PyObject *m, *v, *sysdict;
-	PyObject *sysin, *sysout, *syserr;
-	char *s;
-
-	m = Py_InitModule3("sys", sys_methods, sys_doc);
-	if (m == NULL)
-		return NULL;
-	sysdict = PyModule_GetDict(m);
-#define SET_SYS_FROM_STRING(key, value)			\
-	v = value;					\
-	if (v != NULL)					\
-		PyDict_SetItemString(sysdict, key, v);	\
-	Py_XDECREF(v)
-
-	/* Check that stdin is not a directory
-	Using shell redirection, you can redirect stdin to a directory,
-	crashing the Python interpreter. Catch this common mistake here
-	and output a useful error message. Note that under MS Windows,
-	the shell already prevents that. */
+    PyObject *m, *v, *sysdict;
+    PyObject *sysin, *sysout, *syserr;
+    char *s;
+
+    m = Py_InitModule3("sys", sys_methods, sys_doc);
+    if (m == NULL)
+        return NULL;
+    sysdict = PyModule_GetDict(m);
+#define SET_SYS_FROM_STRING(key, value)                 \
+    v = value;                                          \
+    if (v != NULL)                                      \
+        PyDict_SetItemString(sysdict, key, v);          \
+    Py_XDECREF(v)
+
+    /* Check that stdin is not a directory
+    Using shell redirection, you can redirect stdin to a directory,
+    crashing the Python interpreter. Catch this common mistake here
+    and output a useful error message. Note that under MS Windows,
+    the shell already prevents that. */
 #if !defined(MS_WINDOWS)
-	{
-		struct stat sb;
-		if (fstat(fileno(stdin), &sb) == 0 &&
-		    S_ISDIR(sb.st_mode)) {
-			/* There's nothing more we can do. */
-			/* Py_FatalError() will core dump, so just exit. */
-			PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
-			exit(EXIT_FAILURE);
-		}
-	}
+    {
+        struct stat sb;
+        if (fstat(fileno(stdin), &sb) == 0 &&
+            S_ISDIR(sb.st_mode)) {
+            /* There's nothing more we can do. */
+            /* Py_FatalError() will core dump, so just exit. */
+            PySys_WriteStderr("Python error: <stdin> is a directory, cannot continue\n");
+            exit(EXIT_FAILURE);
+        }
+    }
 #endif
 
-	/* Closing the standard FILE* if sys.std* goes aways causes problems
-	 * for embedded Python usages. Closing them when somebody explicitly
-	 * invokes .close() might be possible, but the FAQ promises they get
-	 * never closed. However, we still need to get write errors when
-	 * writing fails (e.g. because stdout is redirected), so we flush the
-	 * streams and check for errors before the file objects are deleted.
-	 * On OS X, fflush()ing stdin causes an error, so we exempt stdin
-	 * from that procedure.
-	 */
-	sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL);
-	sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush);
-	syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush);
-	if (PyErr_Occurred())
-		return NULL;
-
-	PyDict_SetItemString(sysdict, "stdin", sysin);
-	PyDict_SetItemString(sysdict, "stdout", sysout);
-	PyDict_SetItemString(sysdict, "stderr", syserr);
-	/* Make backup copies for cleanup */
-	PyDict_SetItemString(sysdict, "__stdin__", sysin);
-	PyDict_SetItemString(sysdict, "__stdout__", sysout);
-	PyDict_SetItemString(sysdict, "__stderr__", syserr);
-	PyDict_SetItemString(sysdict, "__displayhook__",
-			     PyDict_GetItemString(sysdict, "displayhook"));
-	PyDict_SetItemString(sysdict, "__excepthook__",
-			     PyDict_GetItemString(sysdict, "excepthook"));
-	Py_XDECREF(sysin);
-	Py_XDECREF(sysout);
-	Py_XDECREF(syserr);
-
-	SET_SYS_FROM_STRING("version",
-			     PyString_FromString(Py_GetVersion()));
-	SET_SYS_FROM_STRING("hexversion",
-			     PyInt_FromLong(PY_VERSION_HEX));
-	svnversion_init();
-	SET_SYS_FROM_STRING("subversion",
-			     Py_BuildValue("(ssz)", "CPython", branch,
-					  svn_revision));
-	SET_SYS_FROM_STRING("dont_write_bytecode",
-			     PyBool_FromLong(Py_DontWriteBytecodeFlag));
-	SET_SYS_FROM_STRING("api_version",
-			    PyInt_FromLong(PYTHON_API_VERSION));
-	SET_SYS_FROM_STRING("copyright",
-			    PyString_FromString(Py_GetCopyright()));
-	SET_SYS_FROM_STRING("platform",
-			    PyString_FromString(Py_GetPlatform()));
-	SET_SYS_FROM_STRING("executable",
-			    PyString_FromString(Py_GetProgramFullPath()));
-	SET_SYS_FROM_STRING("prefix",
-			    PyString_FromString(Py_GetPrefix()));
-	SET_SYS_FROM_STRING("exec_prefix",
-		   	    PyString_FromString(Py_GetExecPrefix()));
-	SET_SYS_FROM_STRING("maxsize",
-			    PyInt_FromSsize_t(PY_SSIZE_T_MAX));
-	SET_SYS_FROM_STRING("maxint",
-			    PyInt_FromLong(PyInt_GetMax()));
-	SET_SYS_FROM_STRING("py3kwarning",
-			    PyBool_FromLong(Py_Py3kWarningFlag));
-	SET_SYS_FROM_STRING("float_info",
-			    PyFloat_GetInfo());
-	SET_SYS_FROM_STRING("long_info",
-			    PyLong_GetInfo());
+    /* Closing the standard FILE* if sys.std* goes aways causes problems
+     * for embedded Python usages. Closing them when somebody explicitly
+     * invokes .close() might be possible, but the FAQ promises they get
+     * never closed. However, we still need to get write errors when
+     * writing fails (e.g. because stdout is redirected), so we flush the
+     * streams and check for errors before the file objects are deleted.
+     * On OS X, fflush()ing stdin causes an error, so we exempt stdin
+     * from that procedure.
+     */
+    sysin = PyFile_FromFile(stdin, "<stdin>", "r", NULL);
+    sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush);
+    syserr = PyFile_FromFile(stderr, "<stderr>", "w", _check_and_flush);
+    if (PyErr_Occurred())
+        return NULL;
+
+    PyDict_SetItemString(sysdict, "stdin", sysin);
+    PyDict_SetItemString(sysdict, "stdout", sysout);
+    PyDict_SetItemString(sysdict, "stderr", syserr);
+    /* Make backup copies for cleanup */
+    PyDict_SetItemString(sysdict, "__stdin__", sysin);
+    PyDict_SetItemString(sysdict, "__stdout__", sysout);
+    PyDict_SetItemString(sysdict, "__stderr__", syserr);
+    PyDict_SetItemString(sysdict, "__displayhook__",
+                         PyDict_GetItemString(sysdict, "displayhook"));
+    PyDict_SetItemString(sysdict, "__excepthook__",
+                         PyDict_GetItemString(sysdict, "excepthook"));
+    Py_XDECREF(sysin);
+    Py_XDECREF(sysout);
+    Py_XDECREF(syserr);
+
+    SET_SYS_FROM_STRING("version",
+                         PyString_FromString(Py_GetVersion()));
+    SET_SYS_FROM_STRING("hexversion",
+                         PyInt_FromLong(PY_VERSION_HEX));
+    svnversion_init();
+    SET_SYS_FROM_STRING("subversion",
+                         Py_BuildValue("(ssz)", "CPython", branch,
+                                      svn_revision));
+    SET_SYS_FROM_STRING("dont_write_bytecode",
+                         PyBool_FromLong(Py_DontWriteBytecodeFlag));
+    SET_SYS_FROM_STRING("api_version",
+                        PyInt_FromLong(PYTHON_API_VERSION));
+    SET_SYS_FROM_STRING("copyright",
+                        PyString_FromString(Py_GetCopyright()));
+    SET_SYS_FROM_STRING("platform",
+                        PyString_FromString(Py_GetPlatform()));
+    SET_SYS_FROM_STRING("executable",
+                        PyString_FromString(Py_GetProgramFullPath()));
+    SET_SYS_FROM_STRING("prefix",
+                        PyString_FromString(Py_GetPrefix()));
+    SET_SYS_FROM_STRING("exec_prefix",
+                        PyString_FromString(Py_GetExecPrefix()));
+    SET_SYS_FROM_STRING("maxsize",
+                        PyInt_FromSsize_t(PY_SSIZE_T_MAX));
+    SET_SYS_FROM_STRING("maxint",
+                        PyInt_FromLong(PyInt_GetMax()));
+    SET_SYS_FROM_STRING("py3kwarning",
+                        PyBool_FromLong(Py_Py3kWarningFlag));
+    SET_SYS_FROM_STRING("float_info",
+                        PyFloat_GetInfo());
+    SET_SYS_FROM_STRING("long_info",
+                        PyLong_GetInfo());
 #ifdef Py_USING_UNICODE
-	SET_SYS_FROM_STRING("maxunicode",
-			    PyInt_FromLong(PyUnicode_GetMax()));
+    SET_SYS_FROM_STRING("maxunicode",
+                        PyInt_FromLong(PyUnicode_GetMax()));
 #endif
-	SET_SYS_FROM_STRING("builtin_module_names",
-			    list_builtin_module_names());
-	{
-		/* Assumes that longs are at least 2 bytes long.
-		   Should be safe! */
-		unsigned long number = 1;
-		char *value;
-
-		s = (char *) &number;
-		if (s[0] == 0)
-			value = "big";
-		else
-			value = "little";
-		SET_SYS_FROM_STRING("byteorder",
-				    PyString_FromString(value));
-	}
+    SET_SYS_FROM_STRING("builtin_module_names",
+                        list_builtin_module_names());
+    {
+        /* Assumes that longs are at least 2 bytes long.
+           Should be safe! */
+        unsigned long number = 1;
+        char *value;
+
+        s = (char *) &number;
+        if (s[0] == 0)
+            value = "big";
+        else
+            value = "little";
+        SET_SYS_FROM_STRING("byteorder",
+                            PyString_FromString(value));
+    }
 #ifdef MS_COREDLL
-	SET_SYS_FROM_STRING("dllhandle",
-			    PyLong_FromVoidPtr(PyWin_DLLhModule));
-	SET_SYS_FROM_STRING("winver",
-			    PyString_FromString(PyWin_DLLVersionString));
+    SET_SYS_FROM_STRING("dllhandle",
+                        PyLong_FromVoidPtr(PyWin_DLLhModule));
+    SET_SYS_FROM_STRING("winver",
+                        PyString_FromString(PyWin_DLLVersionString));
 #endif
-	if (warnoptions == NULL) {
-		warnoptions = PyList_New(0);
-	}
-	else {
-		Py_INCREF(warnoptions);
-	}
-	if (warnoptions != NULL) {
-		PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
-	}
-
-	/* version_info */
-	if (VersionInfoType.tp_name == 0)
-		PyStructSequence_InitType(&VersionInfoType, &version_info_desc);
-	SET_SYS_FROM_STRING("version_info", make_version_info());
-	/* prevent user from creating new instances */
-	VersionInfoType.tp_init = NULL;
-	VersionInfoType.tp_new = NULL;
-
-	/* flags */
-	if (FlagsType.tp_name == 0)
-		PyStructSequence_InitType(&FlagsType, &flags_desc);
-	SET_SYS_FROM_STRING("flags", make_flags());
-	/* prevent user from creating new instances */
-	FlagsType.tp_init = NULL;
-	FlagsType.tp_new = NULL;
+    if (warnoptions == NULL) {
+        warnoptions = PyList_New(0);
+    }
+    else {
+        Py_INCREF(warnoptions);
+    }
+    if (warnoptions != NULL) {
+        PyDict_SetItemString(sysdict, "warnoptions", warnoptions);
+    }
+
+    /* version_info */
+    if (VersionInfoType.tp_name == 0)
+        PyStructSequence_InitType(&VersionInfoType, &version_info_desc);
+    SET_SYS_FROM_STRING("version_info", make_version_info());
+    /* prevent user from creating new instances */
+    VersionInfoType.tp_init = NULL;
+    VersionInfoType.tp_new = NULL;
+
+    /* flags */
+    if (FlagsType.tp_name == 0)
+        PyStructSequence_InitType(&FlagsType, &flags_desc);
+    SET_SYS_FROM_STRING("flags", make_flags());
+    /* prevent user from creating new instances */
+    FlagsType.tp_init = NULL;
+    FlagsType.tp_new = NULL;
 
 
 #if defined(MS_WINDOWS)
-	/* getwindowsversion */
-	if (WindowsVersionType.tp_name == 0)
-		PyStructSequence_InitType(&WindowsVersionType, &windows_version_desc);
-	/* prevent user from creating new instances */
-	WindowsVersionType.tp_init = NULL;
-	WindowsVersionType.tp_new = NULL;
+    /* getwindowsversion */
+    if (WindowsVersionType.tp_name == 0)
+        PyStructSequence_InitType(&WindowsVersionType, &windows_version_desc);
+    /* prevent user from creating new instances */
+    WindowsVersionType.tp_init = NULL;
+    WindowsVersionType.tp_new = NULL;
 #endif
 
-	/* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */
+    /* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */
 #ifndef PY_NO_SHORT_FLOAT_REPR
-	SET_SYS_FROM_STRING("float_repr_style",
-			    PyString_FromString("short"));
+    SET_SYS_FROM_STRING("float_repr_style",
+                        PyString_FromString("short"));
 #else
-	SET_SYS_FROM_STRING("float_repr_style",
-			    PyString_FromString("legacy"));
+    SET_SYS_FROM_STRING("float_repr_style",
+                        PyString_FromString("legacy"));
 #endif
 
 #undef SET_SYS_FROM_STRING
-	if (PyErr_Occurred())
-		return NULL;
-	return m;
+    if (PyErr_Occurred())
+        return NULL;
+    return m;
 }
 
 static PyObject *
 makepathobject(char *path, int delim)
 {
-	int i, n;
-	char *p;
-	PyObject *v, *w;
-
-	n = 1;
-	p = path;
-	while ((p = strchr(p, delim)) != NULL) {
-		n++;
-		p++;
-	}
-	v = PyList_New(n);
-	if (v == NULL)
-		return NULL;
-	for (i = 0; ; i++) {
-		p = strchr(path, delim);
-		if (p == NULL)
-			p = strchr(path, '\0'); /* End of string */
-		w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path));
-		if (w == NULL) {
-			Py_DECREF(v);
-			return NULL;
-		}
-		PyList_SetItem(v, i, w);
-		if (*p == '\0')
-			break;
-		path = p+1;
-	}
-	return v;
+    int i, n;
+    char *p;
+    PyObject *v, *w;
+
+    n = 1;
+    p = path;
+    while ((p = strchr(p, delim)) != NULL) {
+        n++;
+        p++;
+    }
+    v = PyList_New(n);
+    if (v == NULL)
+        return NULL;
+    for (i = 0; ; i++) {
+        p = strchr(path, delim);
+        if (p == NULL)
+            p = strchr(path, '\0'); /* End of string */
+        w = PyString_FromStringAndSize(path, (Py_ssize_t) (p - path));
+        if (w == NULL) {
+            Py_DECREF(v);
+            return NULL;
+        }
+        PyList_SetItem(v, i, w);
+        if (*p == '\0')
+            break;
+        path = p+1;
+    }
+    return v;
 }
 
 void
 PySys_SetPath(char *path)
 {
-	PyObject *v;
-	if ((v = makepathobject(path, DELIM)) == NULL)
-		Py_FatalError("can't create sys.path");
-	if (PySys_SetObject("path", v) != 0)
-		Py_FatalError("can't assign sys.path");
-	Py_DECREF(v);
+    PyObject *v;
+    if ((v = makepathobject(path, DELIM)) == NULL)
+        Py_FatalError("can't create sys.path");
+    if (PySys_SetObject("path", v) != 0)
+        Py_FatalError("can't assign sys.path");
+    Py_DECREF(v);
 }
 
 static PyObject *
 makeargvobject(int argc, char **argv)
 {
-	PyObject *av;
-	if (argc <= 0 || argv == NULL) {
-		/* Ensure at least one (empty) argument is seen */
-		static char *empty_argv[1] = {""};
-		argv = empty_argv;
-		argc = 1;
-	}
-	av = PyList_New(argc);
-	if (av != NULL) {
-		int i;
-		for (i = 0; i < argc; i++) {
+    PyObject *av;
+    if (argc <= 0 || argv == NULL) {
+        /* Ensure at least one (empty) argument is seen */
+        static char *empty_argv[1] = {""};
+        argv = empty_argv;
+        argc = 1;
+    }
+    av = PyList_New(argc);
+    if (av != NULL) {
+        int i;
+        for (i = 0; i < argc; i++) {
 #ifdef __VMS
-			PyObject *v;
-
-			/* argv[0] is the script pathname if known */
-			if (i == 0) {
-				char* fn = decc$translate_vms(argv[0]);
-				if ((fn == (char *)0) || fn == (char *)-1)
-					v = PyString_FromString(argv[0]);
-				else
-					v = PyString_FromString(
-						decc$translate_vms(argv[0]));
-			} else
-				v = PyString_FromString(argv[i]);
+            PyObject *v;
+
+            /* argv[0] is the script pathname if known */
+            if (i == 0) {
+                char* fn = decc$translate_vms(argv[0]);
+                if ((fn == (char *)0) || fn == (char *)-1)
+                    v = PyString_FromString(argv[0]);
+                else
+                    v = PyString_FromString(
+                        decc$translate_vms(argv[0]));
+            } else
+                v = PyString_FromString(argv[i]);
 #else
-			PyObject *v = PyString_FromString(argv[i]);
+            PyObject *v = PyString_FromString(argv[i]);
 #endif
-			if (v == NULL) {
-				Py_DECREF(av);
-				av = NULL;
-				break;
-			}
-			PyList_SetItem(av, i, v);
-		}
-	}
-	return av;
+            if (v == NULL) {
+                Py_DECREF(av);
+                av = NULL;
+                break;
+            }
+            PyList_SetItem(av, i, v);
+        }
+    }
+    return av;
 }
 
 void
 PySys_SetArgv(int argc, char **argv)
 {
 #if defined(HAVE_REALPATH)
-	char fullpath[MAXPATHLEN];
+    char fullpath[MAXPATHLEN];
 #elif defined(MS_WINDOWS) && !defined(MS_WINCE)
-	char fullpath[MAX_PATH];
+    char fullpath[MAX_PATH];
 #endif
-	PyObject *av = makeargvobject(argc, argv);
-	PyObject *path = PySys_GetObject("path");
-	if (av == NULL)
-		Py_FatalError("no mem for sys.argv");
-	if (PySys_SetObject("argv", av) != 0)
-		Py_FatalError("can't assign sys.argv");
-	if (path != NULL) {
-		char *argv0 = argv[0];
-		char *p = NULL;
-		Py_ssize_t n = 0;
-		PyObject *a;
+    PyObject *av = makeargvobject(argc, argv);
+    PyObject *path = PySys_GetObject("path");
+    if (av == NULL)
+        Py_FatalError("no mem for sys.argv");
+    if (PySys_SetObject("argv", av) != 0)
+        Py_FatalError("can't assign sys.argv");
+    if (path != NULL) {
+        char *argv0 = argv[0];
+        char *p = NULL;
+        Py_ssize_t n = 0;
+        PyObject *a;
 #ifdef HAVE_READLINK
-		char link[MAXPATHLEN+1];
-		char argv0copy[2*MAXPATHLEN+1];
-		int nr = 0;
-		if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0)
-			nr = readlink(argv0, link, MAXPATHLEN);
-		if (nr > 0) {
-			/* It's a symlink */
-			link[nr] = '\0';
-			if (link[0] == SEP)
-				argv0 = link; /* Link to absolute path */
-			else if (strchr(link, SEP) == NULL)
-				; /* Link without path */
-			else {
-				/* Must join(dirname(argv0), link) */
-				char *q = strrchr(argv0, SEP);
-				if (q == NULL)
-					argv0 = link; /* argv0 without path */
-				else {
-					/* Must make a copy */
-					strcpy(argv0copy, argv0);
-					q = strrchr(argv0copy, SEP);
-					strcpy(q+1, link);
-					argv0 = argv0copy;
-				}
-			}
-		}
+        char link[MAXPATHLEN+1];
+        char argv0copy[2*MAXPATHLEN+1];
+        int nr = 0;
+        if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0)
+            nr = readlink(argv0, link, MAXPATHLEN);
+        if (nr > 0) {
+            /* It's a symlink */
+            link[nr] = '\0';
+            if (link[0] == SEP)
+                argv0 = link; /* Link to absolute path */
+            else if (strchr(link, SEP) == NULL)
+                ; /* Link without path */
+            else {
+                /* Must join(dirname(argv0), link) */
+                char *q = strrchr(argv0, SEP);
+                if (q == NULL)
+                    argv0 = link; /* argv0 without path */
+                else {
+                    /* Must make a copy */
+                    strcpy(argv0copy, argv0);
+                    q = strrchr(argv0copy, SEP);
+                    strcpy(q+1, link);
+                    argv0 = argv0copy;
+                }
+            }
+        }
 #endif /* HAVE_READLINK */
 #if SEP == '\\' /* Special case for MS filename syntax */
-		if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
-			char *q;
+        if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
+            char *q;
 #if defined(MS_WINDOWS) && !defined(MS_WINCE)
-			/* This code here replaces the first element in argv with the full
-			path that it represents. Under CE, there are no relative paths so
-			the argument must be the full path anyway. */
-			char *ptemp;
-			if (GetFullPathName(argv0,
-					   sizeof(fullpath),
-					   fullpath,
-					   &ptemp)) {
-				argv0 = fullpath;
-			}
+            /* This code here replaces the first element in argv with the full
+            path that it represents. Under CE, there are no relative paths so
+            the argument must be the full path anyway. */
+            char *ptemp;
+            if (GetFullPathName(argv0,
+                               sizeof(fullpath),
+                               fullpath,
+                               &ptemp)) {
+                argv0 = fullpath;
+            }
 #endif
-			p = strrchr(argv0, SEP);
-			/* Test for alternate separator */
-			q = strrchr(p ? p : argv0, '/');
-			if (q != NULL)
-				p = q;
-			if (p != NULL) {
-				n = p + 1 - argv0;
-				if (n > 1 && p[-1] != ':')
-					n--; /* Drop trailing separator */
-			}
-		}
+            p = strrchr(argv0, SEP);
+            /* Test for alternate separator */
+            q = strrchr(p ? p : argv0, '/');
+            if (q != NULL)
+                p = q;
+            if (p != NULL) {
+                n = p + 1 - argv0;
+                if (n > 1 && p[-1] != ':')
+                    n--; /* Drop trailing separator */
+            }
+        }
 #else /* All other filename syntaxes */
-		if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
+        if (argc > 0 && argv0 != NULL && strcmp(argv0, "-c") != 0) {
 #if defined(HAVE_REALPATH)
-			if (realpath(argv0, fullpath)) {
-				argv0 = fullpath;
-			}
+            if (realpath(argv0, fullpath)) {
+                argv0 = fullpath;
+            }
 #endif
-			p = strrchr(argv0, SEP);
-		}
-		if (p != NULL) {
+            p = strrchr(argv0, SEP);
+        }
+        if (p != NULL) {
 #ifndef RISCOS
-			n = p + 1 - argv0;
+            n = p + 1 - argv0;
 #else /* don't include trailing separator */
-			n = p - argv0;
+            n = p - argv0;
 #endif /* RISCOS */
 #if SEP == '/' /* Special case for Unix filename syntax */
-			if (n > 1)
-				n--; /* Drop trailing separator */
+            if (n > 1)
+                n--; /* Drop trailing separator */
 #endif /* Unix */
-		}
+        }
 #endif /* All others */
-		a = PyString_FromStringAndSize(argv0, n);
-		if (a == NULL)
-			Py_FatalError("no mem for sys.path insertion");
-		if (PyList_Insert(path, 0, a) < 0)
-			Py_FatalError("sys.path.insert(0) failed");
-		Py_DECREF(a);
-	}
-	Py_DECREF(av);
+        a = PyString_FromStringAndSize(argv0, n);
+        if (a == NULL)
+            Py_FatalError("no mem for sys.path insertion");
+        if (PyList_Insert(path, 0, a) < 0)
+            Py_FatalError("sys.path.insert(0) failed");
+        Py_DECREF(a);
+    }
+    Py_DECREF(av);
 }
 
 
@@ -1780,48 +1780,48 @@ PySys_SetArgv(int argc, char **argv)
 static void
 mywrite(char *name, FILE *fp, const char *format, va_list va)
 {
-	PyObject *file;
-	PyObject *error_type, *error_value, *error_traceback;
-
-	PyErr_Fetch(&error_type, &error_value, &error_traceback);
-	file = PySys_GetObject(name);
-	if (file == NULL || PyFile_AsFile(file) == fp)
-		vfprintf(fp, format, va);
-	else {
-		char buffer[1001];
-		const int written = PyOS_vsnprintf(buffer, sizeof(buffer),
-						   format, va);
-		if (PyFile_WriteString(buffer, file) != 0) {
-			PyErr_Clear();
-			fputs(buffer, fp);
-		}
-		if (written < 0 || (size_t)written >= sizeof(buffer)) {
-			const char *truncated = "... truncated";
-			if (PyFile_WriteString(truncated, file) != 0) {
-				PyErr_Clear();
-				fputs(truncated, fp);
-			}
-		}
-	}
-	PyErr_Restore(error_type, error_value, error_traceback);
+    PyObject *file;
+    PyObject *error_type, *error_value, *error_traceback;
+
+    PyErr_Fetch(&error_type, &error_value, &error_traceback);
+    file = PySys_GetObject(name);
+    if (file == NULL || PyFile_AsFile(file) == fp)
+        vfprintf(fp, format, va);
+    else {
+        char buffer[1001];
+        const int written = PyOS_vsnprintf(buffer, sizeof(buffer),
+                                           format, va);
+        if (PyFile_WriteString(buffer, file) != 0) {
+            PyErr_Clear();
+            fputs(buffer, fp);
+        }
+        if (written < 0 || (size_t)written >= sizeof(buffer)) {
+            const char *truncated = "... truncated";
+            if (PyFile_WriteString(truncated, file) != 0) {
+                PyErr_Clear();
+                fputs(truncated, fp);
+            }
+        }
+    }
+    PyErr_Restore(error_type, error_value, error_traceback);
 }
 
 void
 PySys_WriteStdout(const char *format, ...)
 {
-	va_list va;
+    va_list va;
 
-	va_start(va, format);
-	mywrite("stdout", stdout, format, va);
-	va_end(va);
+    va_start(va, format);
+    mywrite("stdout", stdout, format, va);
+    va_end(va);
 }
 
 void
 PySys_WriteStderr(const char *format, ...)
 {
-	va_list va;
+    va_list va;
 
-	va_start(va, format);
-	mywrite("stderr", stderr, format, va);
-	va_end(va);
+    va_start(va, format);
+    mywrite("stderr", stderr, format, va);
+    va_end(va);
 }
diff --git a/Python/thread.c b/Python/thread.c
index ff571d8..1578f82 100644
--- a/Python/thread.c
+++ b/Python/thread.c
@@ -46,7 +46,7 @@
 #endif
 
 /* Check if we're running on HP-UX and _SC_THREADS is defined. If so, then
-   enough of the Posix threads package is implimented to support python 
+   enough of the Posix threads package is implimented to support python
    threads.
 
    This is valid for HP-UX 11.23 running on an ia64 system. If needed, add
@@ -64,8 +64,8 @@
 
 #ifdef Py_DEBUG
 static int thread_debug = 0;
-#define dprintf(args)	(void)((thread_debug & 1) && printf args)
-#define d2printf(args)	((thread_debug & 8) && printf args)
+#define dprintf(args)   (void)((thread_debug & 1) && printf args)
+#define d2printf(args)  ((thread_debug & 8) && printf args)
 #else
 #define dprintf(args)
 #define d2printf(args)
@@ -79,20 +79,20 @@ void
 PyThread_init_thread(void)
 {
 #ifdef Py_DEBUG
-	char *p = Py_GETENV("PYTHONTHREADDEBUG");
-
-	if (p) {
-		if (*p)
-			thread_debug = atoi(p);
-		else
-			thread_debug = 1;
-	}
+    char *p = Py_GETENV("PYTHONTHREADDEBUG");
+
+    if (p) {
+        if (*p)
+            thread_debug = atoi(p);
+        else
+            thread_debug = 1;
+    }
 #endif /* Py_DEBUG */
-	if (initialized)
-		return;
-	initialized = 1;
-	dprintf(("PyThread_init_thread called\n"));
-	PyThread__init_thread();
+    if (initialized)
+        return;
+    initialized = 1;
+    dprintf(("PyThread_init_thread called\n"));
+    PyThread__init_thread();
 }
 
 /* Support for runtime thread stack size tuning.
@@ -155,21 +155,21 @@ static size_t _pythread_stacksize = 0;
 size_t
 PyThread_get_stacksize(void)
 {
-	return _pythread_stacksize;
+    return _pythread_stacksize;
 }
 
 /* Only platforms defining a THREAD_SET_STACKSIZE() macro
    in thread_<platform>.h support changing the stack size.
    Return 0 if stack size is valid,
-          -1 if stack size value is invalid,
-          -2 if setting stack size is not supported. */
+      -1 if stack size value is invalid,
+      -2 if setting stack size is not supported. */
 int
 PyThread_set_stacksize(size_t size)
 {
 #if defined(THREAD_SET_STACKSIZE)
-	return THREAD_SET_STACKSIZE(size);
+    return THREAD_SET_STACKSIZE(size);
 #else
-	return -2;
+    return -2;
 #endif
 }
 
@@ -221,15 +221,15 @@ that calls to PyThread_create_key() are serialized externally.
  * to enforce exclusion internally.
  */
 struct key {
-	/* Next record in the list, or NULL if this is the last record. */
-	struct key *next;
+    /* Next record in the list, or NULL if this is the last record. */
+    struct key *next;
 
-	/* The thread id, according to PyThread_get_thread_ident(). */
-	long id;
+    /* The thread id, according to PyThread_get_thread_ident(). */
+    long id;
 
-	/* The key and its associated value. */
-	int key;
-	void *value;
+    /* The key and its associated value. */
+    int key;
+    void *value;
 };
 
 static struct key *keyhead = NULL;
@@ -260,41 +260,41 @@ static int nkeys = 0;  /* PyThread_create_key() hands out nkeys+1 next */
 static struct key *
 find_key(int key, void *value)
 {
-	struct key *p, *prev_p;
-	long id = PyThread_get_thread_ident();
-
-	if (!keymutex)
-		return NULL;
-	PyThread_acquire_lock(keymutex, 1);
-	prev_p = NULL;
-	for (p = keyhead; p != NULL; p = p->next) {
-		if (p->id == id && p->key == key)
-			goto Done;
-		/* Sanity check.  These states should never happen but if
-		 * they do we must abort.  Otherwise we'll end up spinning in
-		 * in a tight loop with the lock held.  A similar check is done
-		 * in pystate.c tstate_delete_common().  */
-		if (p == prev_p)
-			Py_FatalError("tls find_key: small circular list(!)");
-		prev_p = p;
-		if (p->next == keyhead)
-			Py_FatalError("tls find_key: circular list(!)");
-	}
-	if (value == NULL) {
-		assert(p == NULL);
-		goto Done;
-	}
-	p = (struct key *)malloc(sizeof(struct key));
-	if (p != NULL) {
-		p->id = id;
-		p->key = key;
-		p->value = value;
-		p->next = keyhead;
-		keyhead = p;
-	}
+    struct key *p, *prev_p;
+    long id = PyThread_get_thread_ident();
+
+    if (!keymutex)
+        return NULL;
+    PyThread_acquire_lock(keymutex, 1);
+    prev_p = NULL;
+    for (p = keyhead; p != NULL; p = p->next) {
+        if (p->id == id && p->key == key)
+            goto Done;
+        /* Sanity check.  These states should never happen but if
+         * they do we must abort.  Otherwise we'll end up spinning in
+         * in a tight loop with the lock held.  A similar check is done
+         * in pystate.c tstate_delete_common().  */
+        if (p == prev_p)
+            Py_FatalError("tls find_key: small circular list(!)");
+        prev_p = p;
+        if (p->next == keyhead)
+            Py_FatalError("tls find_key: circular list(!)");
+    }
+    if (value == NULL) {
+        assert(p == NULL);
+        goto Done;
+    }
+    p = (struct key *)malloc(sizeof(struct key));
+    if (p != NULL) {
+        p->id = id;
+        p->key = key;
+        p->value = value;
+        p->next = keyhead;
+        keyhead = p;
+    }
  Done:
-	PyThread_release_lock(keymutex);
-	return p;
+    PyThread_release_lock(keymutex);
+    return p;
 }
 
 /* Return a new key.  This must be called before any other functions in
@@ -304,32 +304,32 @@ find_key(int key, void *value)
 int
 PyThread_create_key(void)
 {
-	/* All parts of this function are wrong if it's called by multiple
-	 * threads simultaneously.
-	 */
-	if (keymutex == NULL)
-		keymutex = PyThread_allocate_lock();
-	return ++nkeys;
+    /* All parts of this function are wrong if it's called by multiple
+     * threads simultaneously.
+     */
+    if (keymutex == NULL)
+        keymutex = PyThread_allocate_lock();
+    return ++nkeys;
 }
 
 /* Forget the associations for key across *all* threads. */
 void
 PyThread_delete_key(int key)
 {
-	struct key *p, **q;
-
-	PyThread_acquire_lock(keymutex, 1);
-	q = &keyhead;
-	while ((p = *q) != NULL) {
-		if (p->key == key) {
-			*q = p->next;
-			free((void *)p);
-			/* NB This does *not* free p->value! */
-		}
-		else
-			q = &p->next;
-	}
-	PyThread_release_lock(keymutex);
+    struct key *p, **q;
+
+    PyThread_acquire_lock(keymutex, 1);
+    q = &keyhead;
+    while ((p = *q) != NULL) {
+        if (p->key == key) {
+            *q = p->next;
+            free((void *)p);
+            /* NB This does *not* free p->value! */
+        }
+        else
+            q = &p->next;
+    }
+    PyThread_release_lock(keymutex);
 }
 
 /* Confusing:  If the current thread has an association for key,
@@ -341,14 +341,14 @@ PyThread_delete_key(int key)
 int
 PyThread_set_key_value(int key, void *value)
 {
-	struct key *p;
-
-	assert(value != NULL);
-	p = find_key(key, value);
-	if (p == NULL)
-		return -1;
-	else
-		return 0;
+    struct key *p;
+
+    assert(value != NULL);
+    p = find_key(key, value);
+    if (p == NULL)
+        return -1;
+    else
+        return 0;
 }
 
 /* Retrieve the value associated with key in the current thread, or NULL
@@ -357,34 +357,34 @@ PyThread_set_key_value(int key, void *value)
 void *
 PyThread_get_key_value(int key)
 {
-	struct key *p = find_key(key, NULL);
+    struct key *p = find_key(key, NULL);
 
-	if (p == NULL)
-		return NULL;
-	else
-		return p->value;
+    if (p == NULL)
+        return NULL;
+    else
+        return p->value;
 }
 
 /* Forget the current thread's association for key, if any. */
 void
 PyThread_delete_key_value(int key)
 {
-	long id = PyThread_get_thread_ident();
-	struct key *p, **q;
-
-	PyThread_acquire_lock(keymutex, 1);
-	q = &keyhead;
-	while ((p = *q) != NULL) {
-		if (p->key == key && p->id == id) {
-			*q = p->next;
-			free((void *)p);
-			/* NB This does *not* free p->value! */
-			break;
-		}
-		else
-			q = &p->next;
-	}
-	PyThread_release_lock(keymutex);
+    long id = PyThread_get_thread_ident();
+    struct key *p, **q;
+
+    PyThread_acquire_lock(keymutex, 1);
+    q = &keyhead;
+    while ((p = *q) != NULL) {
+        if (p->key == key && p->id == id) {
+            *q = p->next;
+            free((void *)p);
+            /* NB This does *not* free p->value! */
+            break;
+        }
+        else
+            q = &p->next;
+    }
+    PyThread_release_lock(keymutex);
 }
 
 /* Forget everything not associated with the current thread id.
@@ -395,27 +395,27 @@ PyThread_delete_key_value(int key)
 void
 PyThread_ReInitTLS(void)
 {
-	long id = PyThread_get_thread_ident();
-	struct key *p, **q;
-
-	if (!keymutex)
-		return;
-	
-	/* As with interpreter_lock in PyEval_ReInitThreads()
-	   we just create a new lock without freeing the old one */
-	keymutex = PyThread_allocate_lock();
-
-	/* Delete all keys which do not match the current thread id */
-	q = &keyhead;
-	while ((p = *q) != NULL) {
-		if (p->id != id) {
-			*q = p->next;
-			free((void *)p);
-			/* NB This does *not* free p->value! */
-		}
-		else
-			q = &p->next;
-	}
+    long id = PyThread_get_thread_ident();
+    struct key *p, **q;
+
+    if (!keymutex)
+        return;
+
+    /* As with interpreter_lock in PyEval_ReInitThreads()
+       we just create a new lock without freeing the old one */
+    keymutex = PyThread_allocate_lock();
+
+    /* Delete all keys which do not match the current thread id */
+    q = &keyhead;
+    while ((p = *q) != NULL) {
+        if (p->id != id) {
+            *q = p->next;
+            free((void *)p);
+            /* NB This does *not* free p->value! */
+        }
+        else
+            q = &p->next;
+    }
 }
 
 #endif /* Py_HAVE_NATIVE_TLS */
diff --git a/Python/thread_atheos.h b/Python/thread_atheos.h
index 747a6a2..230594f 100644
--- a/Python/thread_atheos.h
+++ b/Python/thread_atheos.h
@@ -19,8 +19,8 @@ extern int exit_thread(int);
 
 /* Use an atomic counter and a semaphore for maximum speed. */
 typedef struct fastmutex {
-	sem_id sem;
-	atomic_t count;
+    sem_id sem;
+    atomic_t count;
 } fastmutex_t;
 
 
@@ -33,49 +33,49 @@ static int fastmutex_unlock(fastmutex_t * mutex);
 
 static int fastmutex_create(const char *name, fastmutex_t * mutex)
 {
-	mutex->count = 0;
-	mutex->sem = create_semaphore(name, 0, 0);
-	return (mutex->sem < 0) ? -1 : 0;
+    mutex->count = 0;
+    mutex->sem = create_semaphore(name, 0, 0);
+    return (mutex->sem < 0) ? -1 : 0;
 }
 
 
 static int fastmutex_destroy(fastmutex_t * mutex)
 {
-	if (fastmutex_timedlock(mutex, 0) == 0 || errno == EWOULDBLOCK) {
-		return delete_semaphore(mutex->sem);
-	}
-	return 0;
+    if (fastmutex_timedlock(mutex, 0) == 0 || errno == EWOULDBLOCK) {
+        return delete_semaphore(mutex->sem);
+    }
+    return 0;
 }
 
 
 static int fastmutex_lock(fastmutex_t * mutex)
 {
-	atomic_t prev = atomic_add(&mutex->count, 1);
-	if (prev > 0)
-		return lock_semaphore(mutex->sem);
-	return 0;
+    atomic_t prev = atomic_add(&mutex->count, 1);
+    if (prev > 0)
+        return lock_semaphore(mutex->sem);
+    return 0;
 }
 
 
 static int fastmutex_timedlock(fastmutex_t * mutex, bigtime_t timeout)
 {
-	atomic_t prev = atomic_add(&mutex->count, 1);
-	if (prev > 0)
-		return lock_semaphore_x(mutex->sem, 1, 0, timeout);
-	return 0;
+    atomic_t prev = atomic_add(&mutex->count, 1);
+    if (prev > 0)
+        return lock_semaphore_x(mutex->sem, 1, 0, timeout);
+    return 0;
 }
 
 
 static int fastmutex_unlock(fastmutex_t * mutex)
 {
-	atomic_t prev = atomic_add(&mutex->count, -1);
-	if (prev > 1)
-		return unlock_semaphore(mutex->sem);
-	return 0;
+    atomic_t prev = atomic_add(&mutex->count, -1);
+    if (prev > 1)
+        return unlock_semaphore(mutex->sem);
+    return 0;
 }
 
 
-#endif				/* FASTLOCK */
+#endif                          /* FASTLOCK */
 
 
 /*
@@ -84,8 +84,8 @@ static int fastmutex_unlock(fastmutex_t * mutex)
  */
 static void PyThread__init_thread(void)
 {
-	/* Do nothing. */
-	return;
+    /* Do nothing. */
+    return;
 }
 
 
@@ -98,48 +98,48 @@ static atomic_t thread_count = 0;
 
 long PyThread_start_new_thread(void (*func) (void *), void *arg)
 {
-	status_t success = -1;
-	thread_id tid;
-	char name[OS_NAME_LENGTH];
-	atomic_t this_thread;
-
-	dprintf(("PyThread_start_new_thread called\n"));
-
-	this_thread = atomic_add(&thread_count, 1);
-	PyOS_snprintf(name, sizeof(name), "python thread (%d)", this_thread);
-
-	tid = spawn_thread(name, func, NORMAL_PRIORITY, 0, arg);
-	if (tid < 0) {
-		dprintf(("PyThread_start_new_thread spawn_thread failed: %s\n", strerror(errno)));
-	} else {
-		success = resume_thread(tid);
-		if (success < 0) {
-			dprintf(("PyThread_start_new_thread resume_thread failed: %s\n", strerror(errno)));
-		}
-	}
-
-	return (success < 0 ? -1 : tid);
+    status_t success = -1;
+    thread_id tid;
+    char name[OS_NAME_LENGTH];
+    atomic_t this_thread;
+
+    dprintf(("PyThread_start_new_thread called\n"));
+
+    this_thread = atomic_add(&thread_count, 1);
+    PyOS_snprintf(name, sizeof(name), "python thread (%d)", this_thread);
+
+    tid = spawn_thread(name, func, NORMAL_PRIORITY, 0, arg);
+    if (tid < 0) {
+        dprintf(("PyThread_start_new_thread spawn_thread failed: %s\n", strerror(errno)));
+    } else {
+        success = resume_thread(tid);
+        if (success < 0) {
+            dprintf(("PyThread_start_new_thread resume_thread failed: %s\n", strerror(errno)));
+        }
+    }
+
+    return (success < 0 ? -1 : tid);
 }
 
 
 long PyThread_get_thread_ident(void)
 {
-	return get_thread_id(NULL);
+    return get_thread_id(NULL);
 }
 
 
 void PyThread_exit_thread(void)
 {
-	dprintf(("PyThread_exit_thread called\n"));
-
-	/* Thread-safe way to read a variable without a mutex: */
-	if (atomic_add(&thread_count, 0) == 0) {
-		/* No threads around, so exit main(). */
-		exit(0);
-	} else {
-		/* We're a thread */
-		exit_thread(0);
-	}
+    dprintf(("PyThread_exit_thread called\n"));
+
+    /* Thread-safe way to read a variable without a mutex: */
+    if (atomic_add(&thread_count, 0) == 0) {
+        /* No threads around, so exit main(). */
+        exit(0);
+    } else {
+        /* We're a thread */
+        exit_thread(0);
+    }
 }
 
 
@@ -153,107 +153,107 @@ static atomic_t lock_count = 0;
 PyThread_type_lock PyThread_allocate_lock(void)
 {
 #ifdef FASTLOCK
-	fastmutex_t *lock;
+    fastmutex_t *lock;
 #else
-	sem_id sema;
+    sem_id sema;
 #endif
-	char name[OS_NAME_LENGTH];
-	atomic_t this_lock;
+    char name[OS_NAME_LENGTH];
+    atomic_t this_lock;
 
-	dprintf(("PyThread_allocate_lock called\n"));
+    dprintf(("PyThread_allocate_lock called\n"));
 
 #ifdef FASTLOCK
-	lock = (fastmutex_t *) malloc(sizeof(fastmutex_t));
-	if (lock == NULL) {
-		dprintf(("PyThread_allocate_lock failed: out of memory\n"));
-		return (PyThread_type_lock) NULL;
-	}
+    lock = (fastmutex_t *) malloc(sizeof(fastmutex_t));
+    if (lock == NULL) {
+        dprintf(("PyThread_allocate_lock failed: out of memory\n"));
+        return (PyThread_type_lock) NULL;
+    }
 #endif
-	this_lock = atomic_add(&lock_count, 1);
-	PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);
+    this_lock = atomic_add(&lock_count, 1);
+    PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);
 
 #ifdef FASTLOCK
-	if (fastmutex_create(name, lock) < 0) {
-		dprintf(("PyThread_allocate_lock failed: %s\n",
-			 strerror(errno)));
-		free(lock);
-		lock = NULL;
-	}
-	dprintf(("PyThread_allocate_lock()-> %p\n", lock));
-	return (PyThread_type_lock) lock;
+    if (fastmutex_create(name, lock) < 0) {
+        dprintf(("PyThread_allocate_lock failed: %s\n",
+                 strerror(errno)));
+        free(lock);
+        lock = NULL;
+    }
+    dprintf(("PyThread_allocate_lock()-> %p\n", lock));
+    return (PyThread_type_lock) lock;
 #else
-	sema = create_semaphore(name, 1, 0);
-	if (sema < 0) {
-		dprintf(("PyThread_allocate_lock failed: %s\n",
-			 strerror(errno)));
-		sema = 0;
-	}
-	dprintf(("PyThread_allocate_lock()-> %p\n", sema));
-	return (PyThread_type_lock) sema;
+    sema = create_semaphore(name, 1, 0);
+    if (sema < 0) {
+        dprintf(("PyThread_allocate_lock failed: %s\n",
+                 strerror(errno)));
+        sema = 0;
+    }
+    dprintf(("PyThread_allocate_lock()-> %p\n", sema));
+    return (PyThread_type_lock) sema;
 #endif
 }
 
 
 void PyThread_free_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
 
 #ifdef FASTLOCK
-	if (fastmutex_destroy((fastmutex_t *) lock) < 0) {
-		dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,
-			 strerror(errno)));
-	}
-	free(lock);
+    if (fastmutex_destroy((fastmutex_t *) lock) < 0) {
+        dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,
+                 strerror(errno)));
+    }
+    free(lock);
 #else
-	if (delete_semaphore((sem_id) lock) < 0) {
-		dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,
-			 strerror(errno)));
-	}
+    if (delete_semaphore((sem_id) lock) < 0) {
+        dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,
+                 strerror(errno)));
+    }
 #endif
 }
 
 
 int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 {
-	int retval;
+    int retval;
 
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock,
-		 waitflag));
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock,
+             waitflag));
 
 #ifdef FASTLOCK
-	if (waitflag)
-		retval = fastmutex_lock((fastmutex_t *) lock);
-	else
-		retval = fastmutex_timedlock((fastmutex_t *) lock, 0);
+    if (waitflag)
+        retval = fastmutex_lock((fastmutex_t *) lock);
+    else
+        retval = fastmutex_timedlock((fastmutex_t *) lock, 0);
 #else
-	if (waitflag)
-		retval = lock_semaphore((sem_id) lock);
-	else
-		retval = lock_semaphore_x((sem_id) lock, 1, 0, 0);
+    if (waitflag)
+        retval = lock_semaphore((sem_id) lock);
+    else
+        retval = lock_semaphore_x((sem_id) lock, 1, 0, 0);
 #endif
-	if (retval < 0) {
-		dprintf(("PyThread_acquire_lock(%p, %d) failed: %s\n",
-			 lock, waitflag, strerror(errno)));
-	}
-	dprintf(("PyThread_acquire_lock(%p, %d)-> %d\n", lock, waitflag,
-		 retval));
-	return retval < 0 ? 0 : 1;
+    if (retval < 0) {
+        dprintf(("PyThread_acquire_lock(%p, %d) failed: %s\n",
+                 lock, waitflag, strerror(errno)));
+    }
+    dprintf(("PyThread_acquire_lock(%p, %d)-> %d\n", lock, waitflag,
+             retval));
+    return retval < 0 ? 0 : 1;
 }
 
 
 void PyThread_release_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_release_lock(%p) called\n", lock));
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
 
 #ifdef FASTLOCK
-	if (fastmutex_unlock((fastmutex_t *) lock) < 0) {
-		dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,
-			 strerror(errno)));
-	}
+    if (fastmutex_unlock((fastmutex_t *) lock) < 0) {
+        dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,
+                 strerror(errno)));
+    }
 #else
-	if (unlock_semaphore((sem_id) lock) < 0) {
-		dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,
-			 strerror(errno)));
-	}
+    if (unlock_semaphore((sem_id) lock) < 0) {
+        dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,
+                 strerror(errno)));
+    }
 #endif
 }
diff --git a/Python/thread_beos.h b/Python/thread_beos.h
index d12d562..65dc470 100644
--- a/Python/thread_beos.h
+++ b/Python/thread_beos.h
@@ -7,8 +7,8 @@
  * in the Be Developer's Newsletter, Issue #26 (http://www.be.com/).
  */
 typedef struct benaphore {
-	sem_id _sem;
-	int32  _atom;
+    sem_id _sem;
+    int32  _atom;
 } benaphore_t;
 
 static status_t benaphore_create( const char *name, benaphore_t *ben );
@@ -19,79 +19,79 @@ static status_t benaphore_unlock( benaphore_t *ben );
 
 static status_t benaphore_create( const char *name, benaphore_t *ben )
 {
-	if( ben != NULL ) {
-		ben->_atom = 0;
-		ben->_sem = create_sem( 0, name );
-		
-		if( ben->_sem < B_NO_ERROR ) {
-			return B_BAD_SEM_ID;
-		}
-	} else {
-		return EFAULT;
-	}
-	
-	return EOK;
+    if( ben != NULL ) {
+        ben->_atom = 0;
+        ben->_sem = create_sem( 0, name );
+
+        if( ben->_sem < B_NO_ERROR ) {
+            return B_BAD_SEM_ID;
+        }
+    } else {
+        return EFAULT;
+    }
+
+    return EOK;
 }
 
 static status_t benaphore_destroy( benaphore_t *ben )
 {
-	if( ben->_sem >= B_NO_ERROR ) {
-		status_t retval = benaphore_timedlock( ben, 0 );
-		
-		if( retval == EOK || retval == EWOULDBLOCK ) {
-			status_t del_retval = delete_sem( ben->_sem );
-			
-			return del_retval;
-		}
-	}
-
-	return B_BAD_SEM_ID;
+    if( ben->_sem >= B_NO_ERROR ) {
+        status_t retval = benaphore_timedlock( ben, 0 );
+
+        if( retval == EOK || retval == EWOULDBLOCK ) {
+            status_t del_retval = delete_sem( ben->_sem );
+
+            return del_retval;
+        }
+    }
+
+    return B_BAD_SEM_ID;
 }
 
 static status_t benaphore_lock( benaphore_t *ben )
 {
-	int32 prev = atomic_add( &(ben->_atom), 1 );
-	
-	if( prev > 0 ) {
-		return acquire_sem( ben->_sem );
-	}
-	
-	return EOK;
+    int32 prev = atomic_add( &(ben->_atom), 1 );
+
+    if( prev > 0 ) {
+        return acquire_sem( ben->_sem );
+    }
+
+    return EOK;
 }
 
 static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros )
 {
-	int32 prev = atomic_add( &(ben->_atom), 1 );
-	
-	if( prev > 0 ) {
-		status_t retval = acquire_sem_etc( ben->_sem, 1, B_TIMEOUT, micros );
-		
-		switch( retval ) {
-		case B_WOULD_BLOCK:	/* Fall through... */
-		case B_TIMED_OUT:
-			return EWOULDBLOCK;
-			break;
-		case B_OK:
-			return EOK;
-			break;
-		default:
-			return retval;
-			break;
-		}
-	}
-	
-	return EOK;
+    int32 prev = atomic_add( &(ben->_atom), 1 );
+
+    if( prev > 0 ) {
+        status_t retval = acquire_sem_etc( ben->_sem, 1, B_TIMEOUT, micros );
+
+        switch( retval ) {
+        case B_WOULD_BLOCK:             /* Fall through... */
+        case B_TIMED_OUT:
+            return EWOULDBLOCK;
+            break;
+        case B_OK:
+            return EOK;
+            break;
+        default:
+            return retval;
+            break;
+        }
+    }
+
+    return EOK;
 }
 
 static status_t benaphore_unlock( benaphore_t *ben )
 {
-	int32 prev = atomic_add( &(ben->_atom), -1 );
-	
-	if( prev > 1 ) {
-		return release_sem( ben->_sem );
-	}
-	
-	return EOK;
+    int32 prev = atomic_add( &(ben->_atom), -1 );
+
+    if( prev > 1 ) {
+        return release_sem( ben->_sem );
+    }
+
+    return EOK;
 }
 
 /* ----------------------------------------------------------------------
@@ -99,8 +99,8 @@ static status_t benaphore_unlock( benaphore_t *ben )
  */
 static void PyThread__init_thread( void )
 {
-	/* Do nothing. */
-	return;
+    /* Do nothing. */
+    return;
 }
 
 /* ----------------------------------------------------------------------
@@ -114,52 +114,52 @@ static int32 thread_count = 0;
 
 long PyThread_start_new_thread( void (*func)(void *), void *arg )
 {
-	status_t success = 0;
-	thread_id tid;
-	char name[B_OS_NAME_LENGTH];
-	int32 this_thread;
+    status_t success = 0;
+    thread_id tid;
+    char name[B_OS_NAME_LENGTH];
+    int32 this_thread;
 
-	dprintf(("PyThread_start_new_thread called\n"));
+    dprintf(("PyThread_start_new_thread called\n"));
 
-	/* We are so very thread-safe... */
-	this_thread = atomic_add( &thread_count, 1 );
-	PyOS_snprintf(name, sizeof(name),
-		      "python thread (%d)", this_thread );
+    /* We are so very thread-safe... */
+    this_thread = atomic_add( &thread_count, 1 );
+    PyOS_snprintf(name, sizeof(name),
+                  "python thread (%d)", this_thread );
 
-	tid = spawn_thread( (thread_func)func, name,
-	                    B_NORMAL_PRIORITY, arg );
-	if( tid > B_NO_ERROR ) {
-		success = resume_thread( tid );
-	}
+    tid = spawn_thread( (thread_func)func, name,
+                        B_NORMAL_PRIORITY, arg );
+    if( tid > B_NO_ERROR ) {
+        success = resume_thread( tid );
+    }
 
-	return ( success == B_NO_ERROR ? tid : -1 );
+    return ( success == B_NO_ERROR ? tid : -1 );
 }
 
 long PyThread_get_thread_ident( void )
 {
-	/* Presumed to return the current thread's ID... */
-	thread_id tid;
-	tid = find_thread( NULL );
-	
-	return ( tid != B_NAME_NOT_FOUND ? tid : -1 );
+    /* Presumed to return the current thread's ID... */
+    thread_id tid;
+    tid = find_thread( NULL );
+
+    return ( tid != B_NAME_NOT_FOUND ? tid : -1 );
 }
 
 void PyThread_exit_thread( void )
 {
-	int32 threads;
+    int32 threads;
 
-	dprintf(("PyThread_exit_thread called\n"));
+    dprintf(("PyThread_exit_thread called\n"));
 
-	/* Thread-safe way to read a variable without a mutex: */
-	threads = atomic_add( &thread_count, 0 );
+    /* Thread-safe way to read a variable without a mutex: */
+    threads = atomic_add( &thread_count, 0 );
 
-	if( threads == 0 ) {
-		/* No threads around, so exit main(). */
-		exit(0);
-	} else {
-		/* Oh, we're a thread, let's try to exit gracefully... */
-		exit_thread( B_NO_ERROR );
-	}
+    if( threads == 0 ) {
+        /* No threads around, so exit main(). */
+        exit(0);
+    } else {
+        /* Oh, we're a thread, let's try to exit gracefully... */
+        exit_thread( B_NO_ERROR );
+    }
 }
 
 /* ----------------------------------------------------------------------
@@ -170,79 +170,79 @@ static int32 lock_count = 0;
 
 PyThread_type_lock PyThread_allocate_lock( void )
 {
-	benaphore_t *lock;
-	status_t retval;
-	char name[B_OS_NAME_LENGTH];
-	int32 this_lock;
-	
-	dprintf(("PyThread_allocate_lock called\n"));
-
-	lock = (benaphore_t *)malloc( sizeof( benaphore_t ) );
-	if( lock == NULL ) {
-		/* TODO: that's bad, raise MemoryError */
-		return (PyThread_type_lock)NULL;
-	}
-
-	this_lock = atomic_add( &lock_count, 1 );
-	PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);
-
-	retval = benaphore_create( name, lock );
-	if( retval != EOK ) {
-		/* TODO: that's bad, raise an exception */
-		return (PyThread_type_lock)NULL;
-	}
-
-	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-	return (PyThread_type_lock) lock;
+    benaphore_t *lock;
+    status_t retval;
+    char name[B_OS_NAME_LENGTH];
+    int32 this_lock;
+
+    dprintf(("PyThread_allocate_lock called\n"));
+
+    lock = (benaphore_t *)malloc( sizeof( benaphore_t ) );
+    if( lock == NULL ) {
+        /* TODO: that's bad, raise MemoryError */
+        return (PyThread_type_lock)NULL;
+    }
+
+    this_lock = atomic_add( &lock_count, 1 );
+    PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);
+
+    retval = benaphore_create( name, lock );
+    if( retval != EOK ) {
+        /* TODO: that's bad, raise an exception */
+        return (PyThread_type_lock)NULL;
+    }
+
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock) lock;
 }
 
 void PyThread_free_lock( PyThread_type_lock lock )
 {
-	status_t retval;
-
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
-	
-	retval = benaphore_destroy( (benaphore_t *)lock );
-	if( retval != EOK ) {
-		/* TODO: that's bad, raise an exception */
-		return;
-	}
+    status_t retval;
+
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
+
+    retval = benaphore_destroy( (benaphore_t *)lock );
+    if( retval != EOK ) {
+        /* TODO: that's bad, raise an exception */
+        return;
+    }
 }
 
 int PyThread_acquire_lock( PyThread_type_lock lock, int waitflag )
 {
-	int success;
-	status_t retval;
-
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-
-	if( waitflag ) {
-		retval = benaphore_lock( (benaphore_t *)lock );
-	} else {
-		retval = benaphore_timedlock( (benaphore_t *)lock, 0 );
-	}
-	
-	if( retval == EOK ) {
-		success = 1;
-	} else {
-		success = 0;
-		
-		/* TODO: that's bad, raise an exception */
-	}
-
-	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-	return success;
+    int success;
+    status_t retval;
+
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+
+    if( waitflag ) {
+        retval = benaphore_lock( (benaphore_t *)lock );
+    } else {
+        retval = benaphore_timedlock( (benaphore_t *)lock, 0 );
+    }
+
+    if( retval == EOK ) {
+        success = 1;
+    } else {
+        success = 0;
+
+        /* TODO: that's bad, raise an exception */
+    }
+
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
 }
 
 void PyThread_release_lock( PyThread_type_lock lock )
 {
-	status_t retval;
-	
-	dprintf(("PyThread_release_lock(%p) called\n", lock));
-	
-	retval = benaphore_unlock( (benaphore_t *)lock );
-	if( retval != EOK ) {
-		/* TODO: that's bad, raise an exception */
-		return;
-	}
+    status_t retval;
+
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
+
+    retval = benaphore_unlock( (benaphore_t *)lock );
+    if( retval != EOK ) {
+        /* TODO: that's bad, raise an exception */
+        return;
+    }
 }
diff --git a/Python/thread_cthread.h b/Python/thread_cthread.h
index 7163412..1b3e390 100644
--- a/Python/thread_cthread.h
+++ b/Python/thread_cthread.h
@@ -14,12 +14,12 @@ static void
 PyThread__init_thread(void)
 {
 #ifndef HURD_C_THREADS
-	/* Roland McGrath said this should not be used since this is
-	done while linking to threads */
-	cthread_init(); 
+    /* Roland McGrath said this should not be used since this is
+    done while linking to threads */
+    cthread_init();
 #else
 /* do nothing */
-	;
+    ;
 #endif
 }
 
@@ -29,34 +29,34 @@ PyThread__init_thread(void)
 long
 PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-	int success = 0;	/* init not needed when SOLARIS_THREADS and */
-				/* C_THREADS implemented properly */
+    int success = 0;            /* init not needed when SOLARIS_THREADS and */
+                /* C_THREADS implemented properly */
 
-	dprintf(("PyThread_start_new_thread called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-	/* looks like solaris detaches the thread to never rejoin
-	 * so well do it here
-	 */
-	cthread_detach(cthread_fork((cthread_fn_t) func, arg));
-	return success < 0 ? -1 : 0;
+    dprintf(("PyThread_start_new_thread called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+    /* looks like solaris detaches the thread to never rejoin
+     * so well do it here
+     */
+    cthread_detach(cthread_fork((cthread_fn_t) func, arg));
+    return success < 0 ? -1 : 0;
 }
 
 long
 PyThread_get_thread_ident(void)
 {
-	if (!initialized)
-		PyThread_init_thread();
-	return (long) cthread_self();
+    if (!initialized)
+        PyThread_init_thread();
+    return (long) cthread_self();
 }
 
 void
 PyThread_exit_thread(void)
 {
-	dprintf(("PyThread_exit_thread called\n"));
-	if (!initialized)
-		exit(0);
-	cthread_exit(0);
+    dprintf(("PyThread_exit_thread called\n"));
+    if (!initialized)
+        exit(0);
+    cthread_exit(0);
 }
 
 /*
@@ -65,48 +65,48 @@ PyThread_exit_thread(void)
 PyThread_type_lock
 PyThread_allocate_lock(void)
 {
-	mutex_t lock;
+    mutex_t lock;
 
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
 
-	lock = mutex_alloc();
-	if (mutex_init(lock)) {
-		perror("mutex_init");
-		free((void *) lock);
-		lock = 0;
-	}
-	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-	return (PyThread_type_lock) lock;
+    lock = mutex_alloc();
+    if (mutex_init(lock)) {
+        perror("mutex_init");
+        free((void *) lock);
+        lock = 0;
+    }
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock) lock;
 }
 
 void
 PyThread_free_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
-	mutex_free(lock);
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
+    mutex_free(lock);
 }
 
 int
 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 {
-	int success = FALSE;
+    int success = FALSE;
 
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-	if (waitflag) { 	/* blocking */
-		mutex_lock((mutex_t)lock);
-		success = TRUE;
-	} else {		/* non blocking */
-		success = mutex_try_lock((mutex_t)lock);
-	}
-	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-	return success;
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+    if (waitflag) {             /* blocking */
+        mutex_lock((mutex_t)lock);
+        success = TRUE;
+    } else {                    /* non blocking */
+        success = mutex_try_lock((mutex_t)lock);
+    }
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
 }
 
 void
 PyThread_release_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_release_lock(%p) called\n", lock));
-	mutex_unlock((mutex_t )lock);
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
+    mutex_unlock((mutex_t )lock);
 }
diff --git a/Python/thread_foobar.h b/Python/thread_foobar.h
index 1b993d1..d2b78c5 100644
--- a/Python/thread_foobar.h
+++ b/Python/thread_foobar.h
@@ -13,28 +13,28 @@ PyThread__init_thread(void)
 long
 PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-	int success = 0;	/* init not needed when SOLARIS_THREADS and */
-				/* C_THREADS implemented properly */
+    int success = 0;            /* init not needed when SOLARIS_THREADS and */
+                /* C_THREADS implemented properly */
 
-	dprintf(("PyThread_start_new_thread called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-	return success < 0 ? -1 : 0;
+    dprintf(("PyThread_start_new_thread called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+    return success < 0 ? -1 : 0;
 }
 
 long
 PyThread_get_thread_ident(void)
 {
-	if (!initialized)
-		PyThread_init_thread();
+    if (!initialized)
+        PyThread_init_thread();
 }
 
 void
 PyThread_exit_thread(void)
 {
-	dprintf(("PyThread_exit_thread called\n"));
-	if (!initialized)
-		exit(0);
+    dprintf(("PyThread_exit_thread called\n"));
+    if (!initialized)
+        exit(0);
 }
 
 /*
@@ -44,32 +44,32 @@ PyThread_type_lock
 PyThread_allocate_lock(void)
 {
 
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
 
-	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-	return (PyThread_type_lock) lock;
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock) lock;
 }
 
 void
 PyThread_free_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
 }
 
 int
 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 {
-	int success;
+    int success;
 
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-	return success;
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
 }
 
 void
 PyThread_release_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_release_lock(%p) called\n", lock));
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
 }
diff --git a/Python/thread_lwp.h b/Python/thread_lwp.h
index 93d8295..ba7b37a 100644
--- a/Python/thread_lwp.h
+++ b/Python/thread_lwp.h
@@ -3,13 +3,13 @@
 #include <lwp/lwp.h>
 #include <lwp/stackdep.h>
 
-#define STACKSIZE	1000	/* stacksize for a thread */
-#define NSTACKS		2	/* # stacks to be put in cache initially */
+#define STACKSIZE       1000    /* stacksize for a thread */
+#define NSTACKS         2       /* # stacks to be put in cache initially */
 
 struct lock {
-	int lock_locked;
-	cv_t lock_condvar;
-	mon_t lock_monitor;
+    int lock_locked;
+    cv_t lock_condvar;
+    mon_t lock_monitor;
 };
 
 
@@ -18,7 +18,7 @@ struct lock {
  */
 static void PyThread__init_thread(void)
 {
-	lwp_setstkcache(STACKSIZE, NSTACKS);
+    lwp_setstkcache(STACKSIZE, NSTACKS);
 }
 
 /*
@@ -28,31 +28,31 @@ static void PyThread__init_thread(void)
 
 long PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-	thread_t tid;
-	int success;
-	dprintf(("PyThread_start_new_thread called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-	success = lwp_create(&tid, func, MINPRIO, 0, lwp_newstk(), 1, arg);
-	return success < 0 ? -1 : 0;
+    thread_t tid;
+    int success;
+    dprintf(("PyThread_start_new_thread called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+    success = lwp_create(&tid, func, MINPRIO, 0, lwp_newstk(), 1, arg);
+    return success < 0 ? -1 : 0;
 }
 
 long PyThread_get_thread_ident(void)
 {
-	thread_t tid;
-	if (!initialized)
-		PyThread_init_thread();
-	if (lwp_self(&tid) < 0)
-		return -1;
-	return tid.thread_id;
+    thread_t tid;
+    if (!initialized)
+        PyThread_init_thread();
+    if (lwp_self(&tid) < 0)
+        return -1;
+    return tid.thread_id;
 }
 
 void PyThread_exit_thread(void)
 {
-	dprintf(("PyThread_exit_thread called\n"));
-	if (!initialized)
-		exit(0);
-	lwp_destroy(SELF);
+    dprintf(("PyThread_exit_thread called\n"));
+    if (!initialized)
+        exit(0);
+    lwp_destroy(SELF);
 }
 
 /*
@@ -60,54 +60,54 @@ void PyThread_exit_thread(void)
  */
 PyThread_type_lock PyThread_allocate_lock(void)
 {
-	struct lock *lock;
-	extern char *malloc(size_t);
-
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-
-	lock = (struct lock *) malloc(sizeof(struct lock));
-	lock->lock_locked = 0;
-	(void) mon_create(&lock->lock_monitor);
-	(void) cv_create(&lock->lock_condvar, lock->lock_monitor);
-	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-	return (PyThread_type_lock) lock;
+    struct lock *lock;
+    extern char *malloc(size_t);
+
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+
+    lock = (struct lock *) malloc(sizeof(struct lock));
+    lock->lock_locked = 0;
+    (void) mon_create(&lock->lock_monitor);
+    (void) cv_create(&lock->lock_condvar, lock->lock_monitor);
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock) lock;
 }
 
 void PyThread_free_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
-	mon_destroy(((struct lock *) lock)->lock_monitor);
-	free((char *) lock);
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
+    mon_destroy(((struct lock *) lock)->lock_monitor);
+    free((char *) lock);
 }
 
 int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 {
-	int success;
-
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-	success = 0;
-
-	(void) mon_enter(((struct lock *) lock)->lock_monitor);
-	if (waitflag)
-		while (((struct lock *) lock)->lock_locked)
-			cv_wait(((struct lock *) lock)->lock_condvar);
-	if (!((struct lock *) lock)->lock_locked) {
-		success = 1;
-		((struct lock *) lock)->lock_locked = 1;
-	}
-	cv_broadcast(((struct lock *) lock)->lock_condvar);
-	mon_exit(((struct lock *) lock)->lock_monitor);
-	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-	return success;
+    int success;
+
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+    success = 0;
+
+    (void) mon_enter(((struct lock *) lock)->lock_monitor);
+    if (waitflag)
+        while (((struct lock *) lock)->lock_locked)
+            cv_wait(((struct lock *) lock)->lock_condvar);
+    if (!((struct lock *) lock)->lock_locked) {
+        success = 1;
+        ((struct lock *) lock)->lock_locked = 1;
+    }
+    cv_broadcast(((struct lock *) lock)->lock_condvar);
+    mon_exit(((struct lock *) lock)->lock_monitor);
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
 }
 
 void PyThread_release_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_release_lock(%p) called\n", lock));
-	(void) mon_enter(((struct lock *) lock)->lock_monitor);
-	((struct lock *) lock)->lock_locked = 0;
-	cv_broadcast(((struct lock *) lock)->lock_condvar);
-	mon_exit(((struct lock *) lock)->lock_monitor);
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
+    (void) mon_enter(((struct lock *) lock)->lock_monitor);
+    ((struct lock *) lock)->lock_locked = 0;
+    cv_broadcast(((struct lock *) lock)->lock_condvar);
+    mon_exit(((struct lock *) lock)->lock_monitor);
 }
diff --git a/Python/thread_nt.h b/Python/thread_nt.h
index 0c5d192..9796a34 100644
--- a/Python/thread_nt.h
+++ b/Python/thread_nt.h
@@ -10,81 +10,81 @@
 #endif
 
 typedef struct NRMUTEX {
-	LONG   owned ;
-	DWORD  thread_id ;
-	HANDLE hevent ;
+    LONG   owned ;
+    DWORD  thread_id ;
+    HANDLE hevent ;
 } NRMUTEX, *PNRMUTEX ;
 
 
 BOOL
 InitializeNonRecursiveMutex(PNRMUTEX mutex)
 {
-	mutex->owned = -1 ;  /* No threads have entered NonRecursiveMutex */
-	mutex->thread_id = 0 ;
-	mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;
-	return mutex->hevent != NULL ;	/* TRUE if the mutex is created */
+    mutex->owned = -1 ;  /* No threads have entered NonRecursiveMutex */
+    mutex->thread_id = 0 ;
+    mutex->hevent = CreateEvent(NULL, FALSE, FALSE, NULL) ;
+    return mutex->hevent != NULL ;      /* TRUE if the mutex is created */
 }
 
 VOID
 DeleteNonRecursiveMutex(PNRMUTEX mutex)
 {
-	/* No in-use check */
-	CloseHandle(mutex->hevent) ;
-	mutex->hevent = NULL ; /* Just in case */
+    /* No in-use check */
+    CloseHandle(mutex->hevent) ;
+    mutex->hevent = NULL ; /* Just in case */
 }
 
 DWORD
 EnterNonRecursiveMutex(PNRMUTEX mutex, BOOL wait)
 {
-	/* Assume that the thread waits successfully */
-	DWORD ret ;
-
-	/* InterlockedIncrement(&mutex->owned) == 0 means that no thread currently owns the mutex */
-	if (!wait)
-	{
-		if (InterlockedCompareExchange(&mutex->owned, 0, -1) != -1)
-			return WAIT_TIMEOUT ;
-		ret = WAIT_OBJECT_0 ;
-	}
-	else
-		ret = InterlockedIncrement(&mutex->owned) ?
-			/* Some thread owns the mutex, let's wait... */
-			WaitForSingleObject(mutex->hevent, INFINITE) : WAIT_OBJECT_0 ;
-
-	mutex->thread_id = GetCurrentThreadId() ; /* We own it */
-	return ret ;
+    /* Assume that the thread waits successfully */
+    DWORD ret ;
+
+    /* InterlockedIncrement(&mutex->owned) == 0 means that no thread currently owns the mutex */
+    if (!wait)
+    {
+        if (InterlockedCompareExchange(&mutex->owned, 0, -1) != -1)
+            return WAIT_TIMEOUT ;
+        ret = WAIT_OBJECT_0 ;
+    }
+    else
+        ret = InterlockedIncrement(&mutex->owned) ?
+            /* Some thread owns the mutex, let's wait... */
+            WaitForSingleObject(mutex->hevent, INFINITE) : WAIT_OBJECT_0 ;
+
+    mutex->thread_id = GetCurrentThreadId() ; /* We own it */
+    return ret ;
 }
 
 BOOL
 LeaveNonRecursiveMutex(PNRMUTEX mutex)
 {
-	/* We don't own the mutex */
-	mutex->thread_id = 0 ;
-	return
-		InterlockedDecrement(&mutex->owned) < 0 ||
-		SetEvent(mutex->hevent) ; /* Other threads are waiting, wake one on them up */
+    /* We don't own the mutex */
+    mutex->thread_id = 0 ;
+    return
+        InterlockedDecrement(&mutex->owned) < 0 ||
+        SetEvent(mutex->hevent) ; /* Other threads are waiting, wake one on them up */
 }
 
 PNRMUTEX
 AllocNonRecursiveMutex(void)
 {
-	PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
-	if (mutex && !InitializeNonRecursiveMutex(mutex))
-	{
-		free(mutex) ;
-		mutex = NULL ;
-	}
-	return mutex ;
+    PNRMUTEX mutex = (PNRMUTEX)malloc(sizeof(NRMUTEX)) ;
+    if (mutex && !InitializeNonRecursiveMutex(mutex))
+    {
+        free(mutex) ;
+        mutex = NULL ;
+    }
+    return mutex ;
 }
 
 void
 FreeNonRecursiveMutex(PNRMUTEX mutex)
 {
-	if (mutex)
-	{
-		DeleteNonRecursiveMutex(mutex) ;
-		free(mutex) ;
-	}
+    if (mutex)
+    {
+        DeleteNonRecursiveMutex(mutex) ;
+        free(mutex) ;
+    }
 }
 
 long PyThread_get_thread_ident(void);
@@ -102,8 +102,8 @@ PyThread__init_thread(void)
  */
 
 typedef struct {
-	void (*func)(void*);
-	void *arg;
+    void (*func)(void*);
+    void *arg;
 } callobj;
 
 /* thunker to call adapt between the function type used by the system's
@@ -115,66 +115,66 @@ static unsigned __stdcall
 #endif
 bootstrap(void *call)
 {
-	callobj *obj = (callobj*)call;
-	void (*func)(void*) = obj->func;
-	void *arg = obj->arg;
-	HeapFree(GetProcessHeap(), 0, obj);
-	func(arg);
-	return 0;
+    callobj *obj = (callobj*)call;
+    void (*func)(void*) = obj->func;
+    void *arg = obj->arg;
+    HeapFree(GetProcessHeap(), 0, obj);
+    func(arg);
+    return 0;
 }
 
 long
 PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-	HANDLE hThread;
-	unsigned threadID;
-	callobj *obj;
-	
-	dprintf(("%ld: PyThread_start_new_thread called\n",
-		 PyThread_get_thread_ident()));
-	if (!initialized)
-		PyThread_init_thread();
-
-	obj = (callobj*)HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
-	if (!obj)
-		return -1;
-	obj->func = func;
-	obj->arg = arg;
+    HANDLE hThread;
+    unsigned threadID;
+    callobj *obj;
+
+    dprintf(("%ld: PyThread_start_new_thread called\n",
+             PyThread_get_thread_ident()));
+    if (!initialized)
+        PyThread_init_thread();
+
+    obj = (callobj*)HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
+    if (!obj)
+        return -1;
+    obj->func = func;
+    obj->arg = arg;
 #if defined(MS_WINCE)
-	hThread = CreateThread(NULL,
-	                       Py_SAFE_DOWNCAST(_pythread_stacksize, Py_ssize_t, SIZE_T),
-	                       bootstrap, obj, 0, &threadID);
+    hThread = CreateThread(NULL,
+                           Py_SAFE_DOWNCAST(_pythread_stacksize, Py_ssize_t, SIZE_T),
+                           bootstrap, obj, 0, &threadID);
 #else
-	hThread = (HANDLE)_beginthreadex(0,
-			  Py_SAFE_DOWNCAST(_pythread_stacksize,
-					   Py_ssize_t, unsigned int),
-			  bootstrap, obj,
-			  0, &threadID);
+    hThread = (HANDLE)_beginthreadex(0,
+                      Py_SAFE_DOWNCAST(_pythread_stacksize,
+                                       Py_ssize_t, unsigned int),
+                      bootstrap, obj,
+                      0, &threadID);
 #endif
-	if (hThread == 0) {
+    if (hThread == 0) {
 #if defined(MS_WINCE)
-		/* Save error in variable, to prevent PyThread_get_thread_ident
-		   from clobbering it. */
-		unsigned e = GetLastError();
-		dprintf(("%ld: PyThread_start_new_thread failed, win32 error code %u\n",
-		         PyThread_get_thread_ident(), e));
+        /* Save error in variable, to prevent PyThread_get_thread_ident
+           from clobbering it. */
+        unsigned e = GetLastError();
+        dprintf(("%ld: PyThread_start_new_thread failed, win32 error code %u\n",
+                 PyThread_get_thread_ident(), e));
 #else
-		/* I've seen errno == EAGAIN here, which means "there are
-		 * too many threads".
-		 */
-		int e = errno;
-		dprintf(("%ld: PyThread_start_new_thread failed, errno %d\n",
-		         PyThread_get_thread_ident(), e));
+        /* I've seen errno == EAGAIN here, which means "there are
+         * too many threads".
+         */
+        int e = errno;
+        dprintf(("%ld: PyThread_start_new_thread failed, errno %d\n",
+                 PyThread_get_thread_ident(), e));
 #endif
-		threadID = (unsigned)-1;
-		HeapFree(GetProcessHeap(), 0, obj);
-	}
-	else {
-		dprintf(("%ld: PyThread_start_new_thread succeeded: %p\n",
-		         PyThread_get_thread_ident(), (void*)hThread));
-		CloseHandle(hThread);
-	}
-	return (long) threadID;
+        threadID = (unsigned)-1;
+        HeapFree(GetProcessHeap(), 0, obj);
+    }
+    else {
+        dprintf(("%ld: PyThread_start_new_thread succeeded: %p\n",
+                 PyThread_get_thread_ident(), (void*)hThread));
+        CloseHandle(hThread);
+    }
+    return (long) threadID;
 }
 
 /*
@@ -184,22 +184,22 @@ PyThread_start_new_thread(void (*func)(void *), void *arg)
 long
 PyThread_get_thread_ident(void)
 {
-	if (!initialized)
-		PyThread_init_thread();
+    if (!initialized)
+        PyThread_init_thread();
 
-	return GetCurrentThreadId();
+    return GetCurrentThreadId();
 }
 
 void
 PyThread_exit_thread(void)
 {
-	dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
-	if (!initialized)
-		exit(0);
+    dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
+    if (!initialized)
+        exit(0);
 #if defined(MS_WINCE)
-	ExitThread(0);
+    ExitThread(0);
 #else
-	_endthreadex(0);
+    _endthreadex(0);
 #endif
 }
 
@@ -211,25 +211,25 @@ PyThread_exit_thread(void)
 PyThread_type_lock
 PyThread_allocate_lock(void)
 {
-	PNRMUTEX aLock;
+    PNRMUTEX aLock;
 
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
 
-	aLock = AllocNonRecursiveMutex() ;
+    aLock = AllocNonRecursiveMutex() ;
 
-	dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
+    dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
 
-	return (PyThread_type_lock) aLock;
+    return (PyThread_type_lock) aLock;
 }
 
 void
 PyThread_free_lock(PyThread_type_lock aLock)
 {
-	dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
+    dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 
-	FreeNonRecursiveMutex(aLock) ;
+    FreeNonRecursiveMutex(aLock) ;
 }
 
 /*
@@ -241,29 +241,29 @@ PyThread_free_lock(PyThread_type_lock aLock)
 int
 PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
 {
-	int success ;
+    int success ;
 
-	dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
+    dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
 
-	success = aLock && EnterNonRecursiveMutex((PNRMUTEX) aLock, (waitflag ? INFINITE : 0)) == WAIT_OBJECT_0 ;
+    success = aLock && EnterNonRecursiveMutex((PNRMUTEX) aLock, (waitflag ? INFINITE : 0)) == WAIT_OBJECT_0 ;
 
-	dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
+    dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
 
-	return success;
+    return success;
 }
 
 void
 PyThread_release_lock(PyThread_type_lock aLock)
 {
-	dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
+    dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 
-	if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
-		dprintf(("%ld: Could not PyThread_release_lock(%p) error: %ld\n", PyThread_get_thread_ident(), aLock, GetLastError()));
+    if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
+        dprintf(("%ld: Could not PyThread_release_lock(%p) error: %ld\n", PyThread_get_thread_ident(), aLock, GetLastError()));
 }
 
 /* minimum/maximum thread stack sizes supported */
-#define THREAD_MIN_STACKSIZE	0x8000		/* 32kB */
-#define THREAD_MAX_STACKSIZE	0x10000000	/* 256MB */
+#define THREAD_MIN_STACKSIZE    0x8000          /* 32kB */
+#define THREAD_MAX_STACKSIZE    0x10000000      /* 256MB */
 
 /* set the thread stack size.
  * Return 0 if size is valid, -1 otherwise.
@@ -271,22 +271,22 @@ PyThread_release_lock(PyThread_type_lock aLock)
 static int
 _pythread_nt_set_stacksize(size_t size)
 {
-	/* set to default */
-	if (size == 0) {
-		_pythread_stacksize = 0;
-		return 0;
-	}
-
-	/* valid range? */
-	if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
-		_pythread_stacksize = size;
-		return 0;
-	}
-
-	return -1;
+    /* set to default */
+    if (size == 0) {
+        _pythread_stacksize = 0;
+        return 0;
+    }
+
+    /* valid range? */
+    if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
+        _pythread_stacksize = size;
+        return 0;
+    }
+
+    return -1;
 }
 
-#define THREAD_SET_STACKSIZE(x)	_pythread_nt_set_stacksize(x)
+#define THREAD_SET_STACKSIZE(x) _pythread_nt_set_stacksize(x)
 
 
 /* use native Windows TLS functions */
@@ -296,13 +296,13 @@ _pythread_nt_set_stacksize(size_t size)
 int
 PyThread_create_key(void)
 {
-	return (int) TlsAlloc();
+    return (int) TlsAlloc();
 }
 
 void
 PyThread_delete_key(int key)
 {
-	TlsFree(key);
+    TlsFree(key);
 }
 
 /* We must be careful to emulate the strange semantics implemented in thread.c,
@@ -311,42 +311,42 @@ PyThread_delete_key(int key)
 int
 PyThread_set_key_value(int key, void *value)
 {
-	BOOL ok;
-	void *oldvalue;
-
-	assert(value != NULL);
-	oldvalue = TlsGetValue(key);
-	if (oldvalue != NULL)
-		/* ignore value if already set */
-		return 0;
-	ok = TlsSetValue(key, value);
-	if (!ok)
-		return -1;
-	return 0;
+    BOOL ok;
+    void *oldvalue;
+
+    assert(value != NULL);
+    oldvalue = TlsGetValue(key);
+    if (oldvalue != NULL)
+        /* ignore value if already set */
+        return 0;
+    ok = TlsSetValue(key, value);
+    if (!ok)
+        return -1;
+    return 0;
 }
 
 void *
 PyThread_get_key_value(int key)
 {
-	/* because TLS is used in the Py_END_ALLOW_THREAD macro,
-	 * it is necessary to preserve the windows error state, because
-	 * it is assumed to be preserved across the call to the macro.
-	 * Ideally, the macro should be fixed, but it is simpler to
-	 * do it here.
-	 */
-	DWORD error = GetLastError();
-	void *result = TlsGetValue(key);
-	SetLastError(error);
-	return result;
+    /* because TLS is used in the Py_END_ALLOW_THREAD macro,
+     * it is necessary to preserve the windows error state, because
+     * it is assumed to be preserved across the call to the macro.
+     * Ideally, the macro should be fixed, but it is simpler to
+     * do it here.
+     */
+    DWORD error = GetLastError();
+    void *result = TlsGetValue(key);
+    SetLastError(error);
+    return result;
 }
 
 void
 PyThread_delete_key_value(int key)
 {
-	/* NULL is used as "key missing", and it is also the default
-	 * given by TlsGetValue() if nothing has been set yet.
-	 */
-	TlsSetValue(key, NULL);
+    /* NULL is used as "key missing", and it is also the default
+     * given by TlsGetValue() if nothing has been set yet.
+     */
+    TlsSetValue(key, NULL);
 }
 
 /* reinitialization of TLS is not necessary after fork when using
diff --git a/Python/thread_os2.h b/Python/thread_os2.h
index eee8de6..1b264b5 100644
--- a/Python/thread_os2.h
+++ b/Python/thread_os2.h
@@ -16,10 +16,10 @@ long PyThread_get_thread_ident(void);
 
 /* default thread stack size of 64kB */
 #if !defined(THREAD_STACK_SIZE)
-#define	THREAD_STACK_SIZE	0x10000
+#define THREAD_STACK_SIZE       0x10000
 #endif
 
-#define OS2_STACKSIZE(x)	(x ? x : THREAD_STACK_SIZE)
+#define OS2_STACKSIZE(x)        (x ? x : THREAD_STACK_SIZE)
 
 /*
  * Initialization of the C package, should not be needed.
@@ -35,113 +35,113 @@ PyThread__init_thread(void)
 long
 PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-	int thread_id;
+    int thread_id;
 
-	thread_id = _beginthread(func,
-				NULL,
-				OS2_STACKSIZE(_pythread_stacksize),
-				arg);
+    thread_id = _beginthread(func,
+                            NULL,
+                            OS2_STACKSIZE(_pythread_stacksize),
+                            arg);
 
-	if (thread_id == -1) {
-		dprintf(("_beginthread failed. return %ld\n", errno));
-	}
+    if (thread_id == -1) {
+        dprintf(("_beginthread failed. return %ld\n", errno));
+    }
 
-	return thread_id;
+    return thread_id;
 }
 
 long
 PyThread_get_thread_ident(void)
 {
 #if !defined(PYCC_GCC)
-	PPIB pib;
-	PTIB tib;
+    PPIB pib;
+    PTIB tib;
 #endif
 
-	if (!initialized)
-		PyThread_init_thread();
+    if (!initialized)
+        PyThread_init_thread();
 
 #if defined(PYCC_GCC)
-	return _gettid();
+    return _gettid();
 #else
-	DosGetInfoBlocks(&tib, &pib);
-	return tib->tib_ptib2->tib2_ultid;
+    DosGetInfoBlocks(&tib, &pib);
+    return tib->tib_ptib2->tib2_ultid;
 #endif
 }
 
 void
 PyThread_exit_thread(void)
 {
-	dprintf(("%ld: PyThread_exit_thread called\n",
-		 PyThread_get_thread_ident()));
-	if (!initialized)
-		exit(0);
-	_endthread();
+    dprintf(("%ld: PyThread_exit_thread called\n",
+             PyThread_get_thread_ident()));
+    if (!initialized)
+        exit(0);
+    _endthread();
 }
 
 /*
  * Lock support.  This is implemented with an event semaphore and critical
- * sections to make it behave more like a posix mutex than its OS/2 
+ * sections to make it behave more like a posix mutex than its OS/2
  * counterparts.
  */
 
 typedef struct os2_lock_t {
-	int is_set;
-	HEV changed;
+    int is_set;
+    HEV changed;
 } *type_os2_lock;
 
-PyThread_type_lock 
+PyThread_type_lock
 PyThread_allocate_lock(void)
 {
 #if defined(PYCC_GCC)
-	_fmutex *sem = malloc(sizeof(_fmutex));
-	if (!initialized)
-		PyThread_init_thread();
-	dprintf(("%ld: PyThread_allocate_lock() -> %lx\n",
-		 PyThread_get_thread_ident(),
-		 (long)sem));
-	if (_fmutex_create(sem, 0)) {
-		free(sem);
-		sem = NULL;
-	}
-	return (PyThread_type_lock)sem;
+    _fmutex *sem = malloc(sizeof(_fmutex));
+    if (!initialized)
+        PyThread_init_thread();
+    dprintf(("%ld: PyThread_allocate_lock() -> %lx\n",
+             PyThread_get_thread_ident(),
+             (long)sem));
+    if (_fmutex_create(sem, 0)) {
+        free(sem);
+        sem = NULL;
+    }
+    return (PyThread_type_lock)sem;
 #else
-	APIRET rc;
-	type_os2_lock lock = (type_os2_lock)malloc(sizeof(struct os2_lock_t));
+    APIRET rc;
+    type_os2_lock lock = (type_os2_lock)malloc(sizeof(struct os2_lock_t));
 
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
 
-	lock->is_set = 0;
+    lock->is_set = 0;
 
-	DosCreateEventSem(NULL, &lock->changed, 0, 0);
+    DosCreateEventSem(NULL, &lock->changed, 0, 0);
 
-	dprintf(("%ld: PyThread_allocate_lock() -> %p\n", 
-		 PyThread_get_thread_ident(), 
-        	 lock->changed));
+    dprintf(("%ld: PyThread_allocate_lock() -> %p\n",
+             PyThread_get_thread_ident(),
+             lock->changed));
 
-	return (PyThread_type_lock)lock;
+    return (PyThread_type_lock)lock;
 #endif
 }
 
-void 
+void
 PyThread_free_lock(PyThread_type_lock aLock)
 {
 #if !defined(PYCC_GCC)
-	type_os2_lock lock = (type_os2_lock)aLock;
+    type_os2_lock lock = (type_os2_lock)aLock;
 #endif
 
-	dprintf(("%ld: PyThread_free_lock(%p) called\n",
-		 PyThread_get_thread_ident(),aLock));
+    dprintf(("%ld: PyThread_free_lock(%p) called\n",
+             PyThread_get_thread_ident(),aLock));
 
 #if defined(PYCC_GCC)
-	if (aLock) {
-		_fmutex_close((_fmutex *)aLock);
-		free((_fmutex *)aLock);
-	}
+    if (aLock) {
+        _fmutex_close((_fmutex *)aLock);
+        free((_fmutex *)aLock);
+    }
 #else
-	DosCloseEventSem(lock->changed);
-	free(aLock);
+    DosCloseEventSem(lock->changed);
+    free(aLock);
 #endif
 }
 
@@ -150,98 +150,98 @@ PyThread_free_lock(PyThread_type_lock aLock)
  *
  * and 0 if the lock was not acquired.
  */
-int 
+int
 PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
 {
 #if !defined(PYCC_GCC)
-	int   done = 0;
-	ULONG count;
-	PID   pid = 0;
-	TID   tid = 0;
-	type_os2_lock lock = (type_os2_lock)aLock;
+    int   done = 0;
+    ULONG count;
+    PID   pid = 0;
+    TID   tid = 0;
+    type_os2_lock lock = (type_os2_lock)aLock;
 #endif
 
-	dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n",
-		 PyThread_get_thread_ident(),
-		 aLock,
-		 waitflag));
+    dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n",
+             PyThread_get_thread_ident(),
+             aLock,
+             waitflag));
 
 #if defined(PYCC_GCC)
-	/* always successful if the lock doesn't exist */
-	if (aLock &&
-	    _fmutex_request((_fmutex *)aLock, waitflag ? 0 : _FMR_NOWAIT))
-		return 0;
+    /* always successful if the lock doesn't exist */
+    if (aLock &&
+        _fmutex_request((_fmutex *)aLock, waitflag ? 0 : _FMR_NOWAIT))
+        return 0;
 #else
-	while (!done) {
-		/* if the lock is currently set, we have to wait for
-		 * the state to change
-		 */
-		if (lock->is_set) {
-			if (!waitflag)
-				return 0;
-			DosWaitEventSem(lock->changed, SEM_INDEFINITE_WAIT);
-		}
-
-		/* enter a critical section and try to get the semaphore.  If
-		 * it is still locked, we will try again.
-		 */
-		if (DosEnterCritSec())
-			return 0;
-
-		if (!lock->is_set) {
-			lock->is_set = 1;
-			DosResetEventSem(lock->changed, &count);
-			done = 1;
-		}
-
-		DosExitCritSec();
-	}
+    while (!done) {
+        /* if the lock is currently set, we have to wait for
+         * the state to change
+         */
+        if (lock->is_set) {
+            if (!waitflag)
+                return 0;
+            DosWaitEventSem(lock->changed, SEM_INDEFINITE_WAIT);
+        }
+
+        /* enter a critical section and try to get the semaphore.  If
+         * it is still locked, we will try again.
+         */
+        if (DosEnterCritSec())
+            return 0;
+
+        if (!lock->is_set) {
+            lock->is_set = 1;
+            DosResetEventSem(lock->changed, &count);
+            done = 1;
+        }
+
+        DosExitCritSec();
+    }
 #endif
 
-	return 1;
+    return 1;
 }
 
 void
 PyThread_release_lock(PyThread_type_lock aLock)
 {
 #if !defined(PYCC_GCC)
-	type_os2_lock lock = (type_os2_lock)aLock;
+    type_os2_lock lock = (type_os2_lock)aLock;
 #endif
 
-	dprintf(("%ld: PyThread_release_lock(%p) called\n",
-		 PyThread_get_thread_ident(),
-		 aLock));
+    dprintf(("%ld: PyThread_release_lock(%p) called\n",
+             PyThread_get_thread_ident(),
+             aLock));
 
 #if defined(PYCC_GCC)
-	if (aLock)
-		_fmutex_release((_fmutex *)aLock);
+    if (aLock)
+        _fmutex_release((_fmutex *)aLock);
 #else
-	if (!lock->is_set) {
-		dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
-			 PyThread_get_thread_ident(),
-			 aLock,
-			 GetLastError()));
-		return;
-	}
-
-	if (DosEnterCritSec()) {
-		dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
-			 PyThread_get_thread_ident(),
-			 aLock,
-			 GetLastError()));
-		return;
-	}
-
-	lock->is_set = 0;
-	DosPostEventSem(lock->changed);
-
-	DosExitCritSec();
+    if (!lock->is_set) {
+        dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
+                 PyThread_get_thread_ident(),
+                 aLock,
+                 GetLastError()));
+        return;
+    }
+
+    if (DosEnterCritSec()) {
+        dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
+                 PyThread_get_thread_ident(),
+                 aLock,
+                 GetLastError()));
+        return;
+    }
+
+    lock->is_set = 0;
+    DosPostEventSem(lock->changed);
+
+    DosExitCritSec();
 #endif
 }
 
 /* minimum/maximum thread stack sizes supported */
-#define THREAD_MIN_STACKSIZE	0x8000		/* 32kB */
-#define THREAD_MAX_STACKSIZE	0x2000000	/* 32MB */
+#define THREAD_MIN_STACKSIZE    0x8000          /* 32kB */
+#define THREAD_MAX_STACKSIZE    0x2000000       /* 32MB */
 
 /* set the thread stack size.
  * Return 0 if size is valid, -1 otherwise.
@@ -249,19 +249,19 @@ PyThread_release_lock(PyThread_type_lock aLock)
 static int
 _pythread_os2_set_stacksize(size_t size)
 {
-	/* set to default */
-	if (size == 0) {
-		_pythread_stacksize = 0;
-		return 0;
-	}
-
-	/* valid range? */
-	if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
-		_pythread_stacksize = size;
-		return 0;
-	}
-
-	return -1;
+    /* set to default */
+    if (size == 0) {
+        _pythread_stacksize = 0;
+        return 0;
+    }
+
+    /* valid range? */
+    if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
+        _pythread_stacksize = size;
+        return 0;
+    }
+
+    return -1;
 }
 
-#define THREAD_SET_STACKSIZE(x)	_pythread_os2_set_stacksize(x)
+#define THREAD_SET_STACKSIZE(x) _pythread_os2_set_stacksize(x)
diff --git a/Python/thread_pth.h b/Python/thread_pth.h
index f11e484..82a00e7 100644
--- a/Python/thread_pth.h
+++ b/Python/thread_pth.h
@@ -3,7 +3,7 @@
    http://www.gnu.org/software/pth
    2000-05-03 Andy Dustman <andy@dustman.net>
 
-   Adapted from Posix threads interface 
+   Adapted from Posix threads interface
    12 May 1997 -- david arnold <davida@pobox.com>
  */
 
@@ -22,10 +22,10 @@
  */
 
 typedef struct {
-	char             locked; /* 0=unlocked, 1=locked */
-	/* a <cond, mutex> pair to handle an acquire of a locked lock */
-	pth_cond_t   lock_released;
-	pth_mutex_t  mut;
+    char             locked; /* 0=unlocked, 1=locked */
+    /* a <cond, mutex> pair to handle an acquire of a locked lock */
+    pth_cond_t   lock_released;
+    pth_mutex_t  mut;
 } pth_lock;
 
 #define CHECK_STATUS(name)  if (status == -1) { printf("%d ", status); perror(name); error = 1; }
@@ -38,10 +38,10 @@ pth_attr_t PyThread_attr;
 
 static void PyThread__init_thread(void)
 {
-	pth_init();
-	PyThread_attr = pth_attr_new();
-	pth_attr_set(PyThread_attr, PTH_ATTR_STACK_SIZE, 1<<18);
-	pth_attr_set(PyThread_attr, PTH_ATTR_JOINABLE, FALSE);
+    pth_init();
+    PyThread_attr = pth_attr_new();
+    pth_attr_set(PyThread_attr, PTH_ATTR_STACK_SIZE, 1<<18);
+    pth_attr_set(PyThread_attr, PTH_ATTR_JOINABLE, FALSE);
 }
 
 /*
@@ -51,35 +51,35 @@ static void PyThread__init_thread(void)
 
 long PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-	pth_t th;
-	dprintf(("PyThread_start_new_thread called\n"));
-	if (!initialized)
-		PyThread_init_thread();
+    pth_t th;
+    dprintf(("PyThread_start_new_thread called\n"));
+    if (!initialized)
+        PyThread_init_thread();
 
-	th = pth_spawn(PyThread_attr,
-				 (void* (*)(void *))func,
-				 (void *)arg
-				 );
+    th = pth_spawn(PyThread_attr,
+                             (void* (*)(void *))func,
+                             (void *)arg
+                             );
 
-	return th;
+    return th;
 }
 
 long PyThread_get_thread_ident(void)
 {
-	volatile pth_t threadid;
-	if (!initialized)
-		PyThread_init_thread();
-	/* Jump through some hoops for Alpha OSF/1 */
-	threadid = pth_self();
-	return (long) *(long *) &threadid;
+    volatile pth_t threadid;
+    if (!initialized)
+        PyThread_init_thread();
+    /* Jump through some hoops for Alpha OSF/1 */
+    threadid = pth_self();
+    return (long) *(long *) &threadid;
 }
 
 void PyThread_exit_thread(void)
 {
-	dprintf(("PyThread_exit_thread called\n"));
-	if (!initialized) {
-		exit(0);
-	}
+    dprintf(("PyThread_exit_thread called\n"));
+    if (!initialized) {
+        exit(0);
+    }
 }
 
 /*
@@ -87,92 +87,92 @@ void PyThread_exit_thread(void)
  */
 PyThread_type_lock PyThread_allocate_lock(void)
 {
-	pth_lock *lock;
-	int status, error = 0;
-
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-
-	lock = (pth_lock *) malloc(sizeof(pth_lock));
-        memset((void *)lock, '\0', sizeof(pth_lock));
-	if (lock) {
-		lock->locked = 0;
-		status = pth_mutex_init(&lock->mut);
-		CHECK_STATUS("pth_mutex_init");
-		status = pth_cond_init(&lock->lock_released);
-		CHECK_STATUS("pth_cond_init");
-		if (error) {
-			free((void *)lock);
-			lock = NULL;
-		}
-	}
-	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-	return (PyThread_type_lock) lock;
+    pth_lock *lock;
+    int status, error = 0;
+
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+
+    lock = (pth_lock *) malloc(sizeof(pth_lock));
+    memset((void *)lock, '\0', sizeof(pth_lock));
+    if (lock) {
+        lock->locked = 0;
+        status = pth_mutex_init(&lock->mut);
+        CHECK_STATUS("pth_mutex_init");
+        status = pth_cond_init(&lock->lock_released);
+        CHECK_STATUS("pth_cond_init");
+        if (error) {
+            free((void *)lock);
+            lock = NULL;
+        }
+    }
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock) lock;
 }
 
 void PyThread_free_lock(PyThread_type_lock lock)
 {
-	pth_lock *thelock = (pth_lock *)lock;
+    pth_lock *thelock = (pth_lock *)lock;
 
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
 
-	free((void *)thelock);
+    free((void *)thelock);
 }
 
 int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 {
-	int success;
-	pth_lock *thelock = (pth_lock *)lock;
-	int status, error = 0;
-
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-
-	status = pth_mutex_acquire(&thelock->mut, !waitflag, NULL);
-	CHECK_STATUS("pth_mutex_acquire[1]");
-	success = thelock->locked == 0;
-        if (success) thelock->locked = 1;
-        status = pth_mutex_release( &thelock->mut );
-        CHECK_STATUS("pth_mutex_release[1]");
-
-        if ( !success && waitflag ) {
-                /* continue trying until we get the lock */
-
-                /* mut must be locked by me -- part of the condition
-                 * protocol */
-                status = pth_mutex_acquire( &thelock->mut, !waitflag, NULL );
-                CHECK_STATUS("pth_mutex_acquire[2]");
-                while ( thelock->locked ) {
-                        status = pth_cond_await(&thelock->lock_released,
-                                                &thelock->mut, NULL);
-                        CHECK_STATUS("pth_cond_await");
-                }
-                thelock->locked = 1;
-                status = pth_mutex_release( &thelock->mut );
-                CHECK_STATUS("pth_mutex_release[2]");
-                success = 1;
+    int success;
+    pth_lock *thelock = (pth_lock *)lock;
+    int status, error = 0;
+
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+
+    status = pth_mutex_acquire(&thelock->mut, !waitflag, NULL);
+    CHECK_STATUS("pth_mutex_acquire[1]");
+    success = thelock->locked == 0;
+    if (success) thelock->locked = 1;
+    status = pth_mutex_release( &thelock->mut );
+    CHECK_STATUS("pth_mutex_release[1]");
+
+    if ( !success && waitflag ) {
+        /* continue trying until we get the lock */
+
+        /* mut must be locked by me -- part of the condition
+         * protocol */
+        status = pth_mutex_acquire( &thelock->mut, !waitflag, NULL );
+        CHECK_STATUS("pth_mutex_acquire[2]");
+        while ( thelock->locked ) {
+            status = pth_cond_await(&thelock->lock_released,
+                                    &thelock->mut, NULL);
+            CHECK_STATUS("pth_cond_await");
         }
-        if (error) success = 0;
-        dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-	return success;
+        thelock->locked = 1;
+        status = pth_mutex_release( &thelock->mut );
+        CHECK_STATUS("pth_mutex_release[2]");
+        success = 1;
+    }
+    if (error) success = 0;
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
 }
 
 void PyThread_release_lock(PyThread_type_lock lock)
 {
-        pth_lock *thelock = (pth_lock *)lock;
-        int status, error = 0;
+    pth_lock *thelock = (pth_lock *)lock;
+    int status, error = 0;
 
-        dprintf(("PyThread_release_lock(%p) called\n", lock));
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
 
-        status = pth_mutex_acquire( &thelock->mut, 0, NULL );
-        CHECK_STATUS("pth_mutex_acquire[3]");
+    status = pth_mutex_acquire( &thelock->mut, 0, NULL );
+    CHECK_STATUS("pth_mutex_acquire[3]");
 
-        thelock->locked = 0;
+    thelock->locked = 0;
 
-        status = pth_mutex_release( &thelock->mut );
-        CHECK_STATUS("pth_mutex_release[3]");
+    status = pth_mutex_release( &thelock->mut );
+    CHECK_STATUS("pth_mutex_release[3]");
 
-        /* wake up someone (anyone, if any) waiting on the lock */
-        status = pth_cond_notify( &thelock->lock_released, 0 );
-        CHECK_STATUS("pth_cond_notify");
+    /* wake up someone (anyone, if any) waiting on the lock */
+    status = pth_cond_notify( &thelock->lock_released, 0 );
+    CHECK_STATUS("pth_cond_notify");
 }
diff --git a/Python/thread_pthread.h b/Python/thread_pthread.h
index 4305a19..ef49a30 100644
--- a/Python/thread_pthread.h
+++ b/Python/thread_pthread.h
@@ -16,10 +16,10 @@
    be conditional on _POSIX_THREAD_ATTR_STACKSIZE being defined. */
 #ifdef _POSIX_THREAD_ATTR_STACKSIZE
 #ifndef THREAD_STACK_SIZE
-#define	THREAD_STACK_SIZE	0	/* use default stack size */
+#define THREAD_STACK_SIZE       0       /* use default stack size */
 #endif
 /* for safety, ensure a viable minimum stacksize */
-#define	THREAD_STACK_MIN	0x8000	/* 32kB */
+#define THREAD_STACK_MIN        0x8000  /* 32kB */
 #else  /* !_POSIX_THREAD_ATTR_STACKSIZE */
 #ifdef THREAD_STACK_SIZE
 #error "THREAD_STACK_SIZE defined but _POSIX_THREAD_ATTR_STACKSIZE undefined"
@@ -28,9 +28,9 @@
 
 /* The POSIX spec says that implementations supporting the sem_*
    family of functions must indicate this by defining
-   _POSIX_SEMAPHORES. */   
+   _POSIX_SEMAPHORES. */
 #ifdef _POSIX_SEMAPHORES
-/* On FreeBSD 4.x, _POSIX_SEMAPHORES is defined empty, so 
+/* On FreeBSD 4.x, _POSIX_SEMAPHORES is defined empty, so
    we need to add 0 to make it work there as well. */
 #if (_POSIX_SEMAPHORES+0) == -1
 #define HAVE_BROKEN_POSIX_SEMAPHORES
@@ -99,10 +99,10 @@
  */
 
 typedef struct {
-	char             locked; /* 0=unlocked, 1=locked */
-	/* a <cond, mutex> pair to handle an acquire of a locked lock */
-	pthread_cond_t   lock_released;
-	pthread_mutex_t  mut;
+    char             locked; /* 0=unlocked, 1=locked */
+    /* a <cond, mutex> pair to handle an acquire of a locked lock */
+    pthread_cond_t   lock_released;
+    pthread_mutex_t  mut;
 } pthread_lock;
 
 #define CHECK_STATUS(name)  if (status != 0) { perror(name); error = 1; }
@@ -120,11 +120,11 @@ void _noop(void)
 static void
 PyThread__init_thread(void)
 {
-	/* DO AN INIT BY STARTING THE THREAD */
-	static int dummy = 0;
-	pthread_t thread1;
-	pthread_create(&thread1, NULL, (void *) _noop, &dummy);
-	pthread_join(thread1, NULL);
+    /* DO AN INIT BY STARTING THE THREAD */
+    static int dummy = 0;
+    pthread_t thread1;
+    pthread_create(&thread1, NULL, (void *) _noop, &dummy);
+    pthread_join(thread1, NULL);
 }
 
 #else /* !_HAVE_BSDI */
@@ -133,7 +133,7 @@ static void
 PyThread__init_thread(void)
 {
 #if defined(_AIX) && defined(__GNUC__)
-	pthread_init();
+    pthread_init();
 #endif
 }
 
@@ -147,59 +147,59 @@ PyThread__init_thread(void)
 long
 PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-	pthread_t th;
-	int status;
+    pthread_t th;
+    int status;
 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
-	pthread_attr_t attrs;
+    pthread_attr_t attrs;
 #endif
 #if defined(THREAD_STACK_SIZE)
-	size_t	tss;
+    size_t      tss;
 #endif
 
-	dprintf(("PyThread_start_new_thread called\n"));
-	if (!initialized)
-		PyThread_init_thread();
+    dprintf(("PyThread_start_new_thread called\n"));
+    if (!initialized)
+        PyThread_init_thread();
 
 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
-	if (pthread_attr_init(&attrs) != 0)
-		return -1;
+    if (pthread_attr_init(&attrs) != 0)
+        return -1;
 #endif
 #if defined(THREAD_STACK_SIZE)
-	tss = (_pythread_stacksize != 0) ? _pythread_stacksize
-					 : THREAD_STACK_SIZE;
-	if (tss != 0) {
-		if (pthread_attr_setstacksize(&attrs, tss) != 0) {
-			pthread_attr_destroy(&attrs);
-			return -1;
-		}
-	}
+    tss = (_pythread_stacksize != 0) ? _pythread_stacksize
+                                     : THREAD_STACK_SIZE;
+    if (tss != 0) {
+        if (pthread_attr_setstacksize(&attrs, tss) != 0) {
+            pthread_attr_destroy(&attrs);
+            return -1;
+        }
+    }
 #endif
 #if defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
-        pthread_attr_setscope(&attrs, PTHREAD_SCOPE_SYSTEM);
+    pthread_attr_setscope(&attrs, PTHREAD_SCOPE_SYSTEM);
 #endif
 
-	status = pthread_create(&th, 
+    status = pthread_create(&th,
 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
-				 &attrs,
+                             &attrs,
 #else
-				 (pthread_attr_t*)NULL,
+                             (pthread_attr_t*)NULL,
 #endif
-				 (void* (*)(void *))func,
-				 (void *)arg
-				 );
+                             (void* (*)(void *))func,
+                             (void *)arg
+                             );
 
 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
-	pthread_attr_destroy(&attrs);
+    pthread_attr_destroy(&attrs);
 #endif
-	if (status != 0)
-            return -1;
+    if (status != 0)
+        return -1;
 
-        pthread_detach(th);
+    pthread_detach(th);
 
 #if SIZEOF_PTHREAD_T <= SIZEOF_LONG
-	return (long) th;
+    return (long) th;
 #else
-	return (long) *(long *) &th;
+    return (long) *(long *) &th;
 #endif
 }
 
@@ -210,28 +210,28 @@ PyThread_start_new_thread(void (*func)(void *), void *arg)
      - It is not clear that the 'volatile' (for AIX?) and ugly casting in the
        latter return statement (for Alpha OSF/1) are any longer necessary.
 */
-long 
+long
 PyThread_get_thread_ident(void)
 {
-	volatile pthread_t threadid;
-	if (!initialized)
-		PyThread_init_thread();
-	/* Jump through some hoops for Alpha OSF/1 */
-	threadid = pthread_self();
+    volatile pthread_t threadid;
+    if (!initialized)
+        PyThread_init_thread();
+    /* Jump through some hoops for Alpha OSF/1 */
+    threadid = pthread_self();
 #if SIZEOF_PTHREAD_T <= SIZEOF_LONG
-	return (long) threadid;
+    return (long) threadid;
 #else
-	return (long) *(long *) &threadid;
+    return (long) *(long *) &threadid;
 #endif
 }
 
-void 
+void
 PyThread_exit_thread(void)
 {
-	dprintf(("PyThread_exit_thread called\n"));
-	if (!initialized) {
-		exit(0);
-	}
+    dprintf(("PyThread_exit_thread called\n"));
+    if (!initialized) {
+        exit(0);
+    }
 }
 
 #ifdef USE_SEMAPHORES
@@ -240,47 +240,47 @@ PyThread_exit_thread(void)
  * Lock support.
  */
 
-PyThread_type_lock 
+PyThread_type_lock
 PyThread_allocate_lock(void)
 {
-	sem_t *lock;
-	int status, error = 0;
+    sem_t *lock;
+    int status, error = 0;
 
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
 
-	lock = (sem_t *)malloc(sizeof(sem_t));
+    lock = (sem_t *)malloc(sizeof(sem_t));
 
-	if (lock) {
-		status = sem_init(lock,0,1);
-		CHECK_STATUS("sem_init");
+    if (lock) {
+        status = sem_init(lock,0,1);
+        CHECK_STATUS("sem_init");
 
-		if (error) {
-			free((void *)lock);
-			lock = NULL;
-		}
-	}
+        if (error) {
+            free((void *)lock);
+            lock = NULL;
+        }
+    }
 
-	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-	return (PyThread_type_lock)lock;
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock)lock;
 }
 
-void 
+void
 PyThread_free_lock(PyThread_type_lock lock)
 {
-	sem_t *thelock = (sem_t *)lock;
-	int status, error = 0;
+    sem_t *thelock = (sem_t *)lock;
+    int status, error = 0;
 
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
 
-	if (!thelock)
-		return;
+    if (!thelock)
+        return;
 
-	status = sem_destroy(thelock);
-	CHECK_STATUS("sem_destroy");
+    status = sem_destroy(thelock);
+    CHECK_STATUS("sem_destroy");
 
-	free((void *)thelock);
+    free((void *)thelock);
 }
 
 /*
@@ -292,47 +292,47 @@ PyThread_free_lock(PyThread_type_lock lock)
 static int
 fix_status(int status)
 {
-	return (status == -1) ? errno : status;
+    return (status == -1) ? errno : status;
 }
 
-int 
+int
 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 {
-	int success;
-	sem_t *thelock = (sem_t *)lock;
-	int status, error = 0;
-
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-
-	do {
-		if (waitflag)
-			status = fix_status(sem_wait(thelock));
-		else
-			status = fix_status(sem_trywait(thelock));
-	} while (status == EINTR); /* Retry if interrupted by a signal */
-
-	if (waitflag) {
-		CHECK_STATUS("sem_wait");
-	} else if (status != EAGAIN) {
-		CHECK_STATUS("sem_trywait");
-	}
-	
-	success = (status == 0) ? 1 : 0;
-
-	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-	return success;
+    int success;
+    sem_t *thelock = (sem_t *)lock;
+    int status, error = 0;
+
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+
+    do {
+        if (waitflag)
+            status = fix_status(sem_wait(thelock));
+        else
+            status = fix_status(sem_trywait(thelock));
+    } while (status == EINTR); /* Retry if interrupted by a signal */
+
+    if (waitflag) {
+        CHECK_STATUS("sem_wait");
+    } else if (status != EAGAIN) {
+        CHECK_STATUS("sem_trywait");
+    }
+
+    success = (status == 0) ? 1 : 0;
+
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
 }
 
-void 
+void
 PyThread_release_lock(PyThread_type_lock lock)
 {
-	sem_t *thelock = (sem_t *)lock;
-	int status, error = 0;
+    sem_t *thelock = (sem_t *)lock;
+    int status, error = 0;
 
-	dprintf(("PyThread_release_lock(%p) called\n", lock));
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
 
-	status = sem_post(thelock);
-	CHECK_STATUS("sem_post");
+    status = sem_post(thelock);
+    CHECK_STATUS("sem_post");
 }
 
 #else /* USE_SEMAPHORES */
@@ -340,109 +340,109 @@ PyThread_release_lock(PyThread_type_lock lock)
 /*
  * Lock support.
  */
-PyThread_type_lock 
+PyThread_type_lock
 PyThread_allocate_lock(void)
 {
-	pthread_lock *lock;
-	int status, error = 0;
-
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-
-	lock = (pthread_lock *) malloc(sizeof(pthread_lock));
-	if (lock) {
-		memset((void *)lock, '\0', sizeof(pthread_lock));
-		lock->locked = 0;
-
-		status = pthread_mutex_init(&lock->mut,
-					    pthread_mutexattr_default);
-		CHECK_STATUS("pthread_mutex_init");
-
-		status = pthread_cond_init(&lock->lock_released,
-					   pthread_condattr_default);
-		CHECK_STATUS("pthread_cond_init");
-
-		if (error) {
-			free((void *)lock);
-			lock = 0;
-		}
-	}
-
-	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-	return (PyThread_type_lock) lock;
+    pthread_lock *lock;
+    int status, error = 0;
+
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+
+    lock = (pthread_lock *) malloc(sizeof(pthread_lock));
+    if (lock) {
+        memset((void *)lock, '\0', sizeof(pthread_lock));
+        lock->locked = 0;
+
+        status = pthread_mutex_init(&lock->mut,
+                                    pthread_mutexattr_default);
+        CHECK_STATUS("pthread_mutex_init");
+
+        status = pthread_cond_init(&lock->lock_released,
+                                   pthread_condattr_default);
+        CHECK_STATUS("pthread_cond_init");
+
+        if (error) {
+            free((void *)lock);
+            lock = 0;
+        }
+    }
+
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock) lock;
 }
 
-void 
+void
 PyThread_free_lock(PyThread_type_lock lock)
 {
-	pthread_lock *thelock = (pthread_lock *)lock;
-	int status, error = 0;
+    pthread_lock *thelock = (pthread_lock *)lock;
+    int status, error = 0;
 
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
 
-	status = pthread_mutex_destroy( &thelock->mut );
-	CHECK_STATUS("pthread_mutex_destroy");
+    status = pthread_mutex_destroy( &thelock->mut );
+    CHECK_STATUS("pthread_mutex_destroy");
 
-	status = pthread_cond_destroy( &thelock->lock_released );
-	CHECK_STATUS("pthread_cond_destroy");
+    status = pthread_cond_destroy( &thelock->lock_released );
+    CHECK_STATUS("pthread_cond_destroy");
 
-	free((void *)thelock);
+    free((void *)thelock);
 }
 
-int 
+int
 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 {
-	int success;
-	pthread_lock *thelock = (pthread_lock *)lock;
-	int status, error = 0;
-
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-
-	status = pthread_mutex_lock( &thelock->mut );
-	CHECK_STATUS("pthread_mutex_lock[1]");
-	success = thelock->locked == 0;
-
-	if ( !success && waitflag ) {
-		/* continue trying until we get the lock */
-
-		/* mut must be locked by me -- part of the condition
-		 * protocol */
-		while ( thelock->locked ) {
-			status = pthread_cond_wait(&thelock->lock_released,
-						   &thelock->mut);
-			CHECK_STATUS("pthread_cond_wait");
-		}
-		success = 1;
-	}
-	if (success) thelock->locked = 1;
-	status = pthread_mutex_unlock( &thelock->mut );
-	CHECK_STATUS("pthread_mutex_unlock[1]");
-
-	if (error) success = 0;
-	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-	return success;
+    int success;
+    pthread_lock *thelock = (pthread_lock *)lock;
+    int status, error = 0;
+
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+
+    status = pthread_mutex_lock( &thelock->mut );
+    CHECK_STATUS("pthread_mutex_lock[1]");
+    success = thelock->locked == 0;
+
+    if ( !success && waitflag ) {
+        /* continue trying until we get the lock */
+
+        /* mut must be locked by me -- part of the condition
+         * protocol */
+        while ( thelock->locked ) {
+            status = pthread_cond_wait(&thelock->lock_released,
+                                       &thelock->mut);
+            CHECK_STATUS("pthread_cond_wait");
+        }
+        success = 1;
+    }
+    if (success) thelock->locked = 1;
+    status = pthread_mutex_unlock( &thelock->mut );
+    CHECK_STATUS("pthread_mutex_unlock[1]");
+
+    if (error) success = 0;
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
 }
 
-void 
+void
 PyThread_release_lock(PyThread_type_lock lock)
 {
-	pthread_lock *thelock = (pthread_lock *)lock;
-	int status, error = 0;
+    pthread_lock *thelock = (pthread_lock *)lock;
+    int status, error = 0;
 
-	dprintf(("PyThread_release_lock(%p) called\n", lock));
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
 
-	status = pthread_mutex_lock( &thelock->mut );
-	CHECK_STATUS("pthread_mutex_lock[3]");
+    status = pthread_mutex_lock( &thelock->mut );
+    CHECK_STATUS("pthread_mutex_lock[3]");
 
-	thelock->locked = 0;
+    thelock->locked = 0;
 
-	status = pthread_mutex_unlock( &thelock->mut );
-	CHECK_STATUS("pthread_mutex_unlock[3]");
+    status = pthread_mutex_unlock( &thelock->mut );
+    CHECK_STATUS("pthread_mutex_unlock[3]");
 
-	/* wake up someone (anyone, if any) waiting on the lock */
-	status = pthread_cond_signal( &thelock->lock_released );
-	CHECK_STATUS("pthread_cond_signal");
+    /* wake up someone (anyone, if any) waiting on the lock */
+    status = pthread_cond_signal( &thelock->lock_released );
+    CHECK_STATUS("pthread_cond_signal");
 }
 
 #endif /* USE_SEMAPHORES */
@@ -455,39 +455,39 @@ static int
 _pythread_pthread_set_stacksize(size_t size)
 {
 #if defined(THREAD_STACK_SIZE)
-	pthread_attr_t attrs;
-	size_t tss_min;
-	int rc = 0;
+    pthread_attr_t attrs;
+    size_t tss_min;
+    int rc = 0;
 #endif
 
-	/* set to default */
-	if (size == 0) {
-		_pythread_stacksize = 0;
-		return 0;
-	}
+    /* set to default */
+    if (size == 0) {
+        _pythread_stacksize = 0;
+        return 0;
+    }
 
 #if defined(THREAD_STACK_SIZE)
 #if defined(PTHREAD_STACK_MIN)
-	tss_min = PTHREAD_STACK_MIN > THREAD_STACK_MIN ? PTHREAD_STACK_MIN
-						       : THREAD_STACK_MIN;
+    tss_min = PTHREAD_STACK_MIN > THREAD_STACK_MIN ? PTHREAD_STACK_MIN
+                                                   : THREAD_STACK_MIN;
 #else
-	tss_min = THREAD_STACK_MIN;
+    tss_min = THREAD_STACK_MIN;
 #endif
-	if (size >= tss_min) {
-		/* validate stack size by setting thread attribute */
-		if (pthread_attr_init(&attrs) == 0) {
-			rc = pthread_attr_setstacksize(&attrs, size);
-			pthread_attr_destroy(&attrs);
-			if (rc == 0) {
-				_pythread_stacksize = size;
-				return 0;
-			}
-		}
-	}
-	return -1;
+    if (size >= tss_min) {
+        /* validate stack size by setting thread attribute */
+        if (pthread_attr_init(&attrs) == 0) {
+            rc = pthread_attr_setstacksize(&attrs, size);
+            pthread_attr_destroy(&attrs);
+            if (rc == 0) {
+                _pythread_stacksize = size;
+                return 0;
+            }
+        }
+    }
+    return -1;
 #else
-	return -2;
+    return -2;
 #endif
 }
 
-#define THREAD_SET_STACKSIZE(x)	_pythread_pthread_set_stacksize(x)
+#define THREAD_SET_STACKSIZE(x) _pythread_pthread_set_stacksize(x)
diff --git a/Python/thread_sgi.h b/Python/thread_sgi.h
index 4f4b210..771ab2c 100644
--- a/Python/thread_sgi.h
+++ b/Python/thread_sgi.h
@@ -8,67 +8,67 @@
 #include <ulocks.h>
 #include <errno.h>
 
-#define HDR_SIZE	2680	/* sizeof(ushdr_t) */
-#define MAXPROC		100	/* max # of threads that can be started */
+#define HDR_SIZE        2680    /* sizeof(ushdr_t) */
+#define MAXPROC         100     /* max # of threads that can be started */
 
 static usptr_t *shared_arena;
-static ulock_t count_lock;	/* protection for some variables */
-static ulock_t wait_lock;	/* lock used to wait for other threads */
-static int waiting_for_threads;	/* protected by count_lock */
-static int nthreads;		/* protected by count_lock */
+static ulock_t count_lock;      /* protection for some variables */
+static ulock_t wait_lock;       /* lock used to wait for other threads */
+static int waiting_for_threads; /* protected by count_lock */
+static int nthreads;            /* protected by count_lock */
 static int exit_status;
-static int exiting;		/* we're already exiting (for maybe_exit) */
-static pid_t my_pid;		/* PID of main thread */
+static int exiting;             /* we're already exiting (for maybe_exit) */
+static pid_t my_pid;            /* PID of main thread */
 static struct pidlist {
-	pid_t parent;
-	pid_t child;
-} pidlist[MAXPROC];	/* PIDs of other threads; protected by count_lock */
-static int maxpidindex;		/* # of PIDs in pidlist */
+    pid_t parent;
+    pid_t child;
+} pidlist[MAXPROC];     /* PIDs of other threads; protected by count_lock */
+static int maxpidindex;         /* # of PIDs in pidlist */
 /*
  * Initialization.
  */
 static void PyThread__init_thread(void)
 {
 #ifdef USE_DL
-	long addr, size;
+    long addr, size;
 #endif /* USE_DL */
 
 
 #ifdef USE_DL
-	if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
-		perror("usconfig - CONF_INITSIZE (check)");
-	if (usconfig(CONF_INITSIZE, size) < 0)
-		perror("usconfig - CONF_INITSIZE (reset)");
-	addr = (long) dl_getrange(size + HDR_SIZE);
-	dprintf(("trying to use addr %p-%p for shared arena\n", addr, addr+size));
-	errno = 0;
-	if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 && errno != 0)
-		perror("usconfig - CONF_ATTACHADDR (set)");
+    if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
+        perror("usconfig - CONF_INITSIZE (check)");
+    if (usconfig(CONF_INITSIZE, size) < 0)
+        perror("usconfig - CONF_INITSIZE (reset)");
+    addr = (long) dl_getrange(size + HDR_SIZE);
+    dprintf(("trying to use addr %p-%p for shared arena\n", addr, addr+size));
+    errno = 0;
+    if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 && errno != 0)
+        perror("usconfig - CONF_ATTACHADDR (set)");
 #endif /* USE_DL */
-	if (usconfig(CONF_INITUSERS, 16) < 0)
-		perror("usconfig - CONF_INITUSERS");
-	my_pid = getpid();	/* so that we know which is the main thread */
-	if (usconfig(CONF_ARENATYPE, US_SHAREDONLY) < 0)
-		perror("usconfig - CONF_ARENATYPE");
-	usconfig(CONF_LOCKTYPE, US_DEBUG); /* XXX */
+    if (usconfig(CONF_INITUSERS, 16) < 0)
+        perror("usconfig - CONF_INITUSERS");
+    my_pid = getpid();          /* so that we know which is the main thread */
+    if (usconfig(CONF_ARENATYPE, US_SHAREDONLY) < 0)
+        perror("usconfig - CONF_ARENATYPE");
+    usconfig(CONF_LOCKTYPE, US_DEBUG); /* XXX */
 #ifdef Py_DEBUG
-	if (thread_debug & 4)
-		usconfig(CONF_LOCKTYPE, US_DEBUGPLUS);
-	else if (thread_debug & 2)
-		usconfig(CONF_LOCKTYPE, US_DEBUG);
+    if (thread_debug & 4)
+        usconfig(CONF_LOCKTYPE, US_DEBUGPLUS);
+    else if (thread_debug & 2)
+        usconfig(CONF_LOCKTYPE, US_DEBUG);
 #endif /* Py_DEBUG */
-	if ((shared_arena = usinit(tmpnam(0))) == 0)
-		perror("usinit");
+    if ((shared_arena = usinit(tmpnam(0))) == 0)
+        perror("usinit");
 #ifdef USE_DL
-	if (usconfig(CONF_ATTACHADDR, addr) < 0) /* reset address */
-		perror("usconfig - CONF_ATTACHADDR (reset)");
+    if (usconfig(CONF_ATTACHADDR, addr) < 0) /* reset address */
+        perror("usconfig - CONF_ATTACHADDR (reset)");
 #endif /* USE_DL */
-	if ((count_lock = usnewlock(shared_arena)) == NULL)
-		perror("usnewlock (count_lock)");
-	(void) usinitlock(count_lock);
-	if ((wait_lock = usnewlock(shared_arena)) == NULL)
-		perror("usnewlock (wait_lock)");
-	dprintf(("arena start: %p, arena size: %ld\n",  shared_arena, (long) usconfig(CONF_GETSIZE, shared_arena)));
+    if ((count_lock = usnewlock(shared_arena)) == NULL)
+        perror("usnewlock (count_lock)");
+    (void) usinitlock(count_lock);
+    if ((wait_lock = usnewlock(shared_arena)) == NULL)
+        perror("usnewlock (wait_lock)");
+    dprintf(("arena start: %p, arena size: %ld\n",  shared_arena, (long) usconfig(CONF_GETSIZE, shared_arena)));
 }
 
 /*
@@ -77,138 +77,138 @@ static void PyThread__init_thread(void)
 
 static void clean_threads(void)
 {
-	int i, j;
-	pid_t mypid, pid;
+    int i, j;
+    pid_t mypid, pid;
 
-	/* clean up any exited threads */
-	mypid = getpid();
-	i = 0;
-	while (i < maxpidindex) {
-		if (pidlist[i].parent == mypid && (pid = pidlist[i].child) > 0) {
-			pid = waitpid(pid, 0, WNOHANG);
-			if (pid > 0) {
-				/* a thread has exited */
-				pidlist[i] = pidlist[--maxpidindex];
-				/* remove references to children of dead proc */
-				for (j = 0; j < maxpidindex; j++)
-					if (pidlist[j].parent == pid)
-						pidlist[j].child = -1;
-				continue; /* don't increment i */
-			}
-		}
-		i++;
-	}
-	/* clean up the list */
-	i = 0;
-	while (i < maxpidindex) {
-		if (pidlist[i].child == -1) {
-			pidlist[i] = pidlist[--maxpidindex];
-			continue; /* don't increment i */
-		}
-		i++;
-	}
+    /* clean up any exited threads */
+    mypid = getpid();
+    i = 0;
+    while (i < maxpidindex) {
+        if (pidlist[i].parent == mypid && (pid = pidlist[i].child) > 0) {
+            pid = waitpid(pid, 0, WNOHANG);
+            if (pid > 0) {
+                /* a thread has exited */
+                pidlist[i] = pidlist[--maxpidindex];
+                /* remove references to children of dead proc */
+                for (j = 0; j < maxpidindex; j++)
+                    if (pidlist[j].parent == pid)
+                        pidlist[j].child = -1;
+                continue; /* don't increment i */
+            }
+        }
+        i++;
+    }
+    /* clean up the list */
+    i = 0;
+    while (i < maxpidindex) {
+        if (pidlist[i].child == -1) {
+            pidlist[i] = pidlist[--maxpidindex];
+            continue; /* don't increment i */
+        }
+        i++;
+    }
 }
 
 long PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
 #ifdef USE_DL
-	long addr, size;
-	static int local_initialized = 0;
+    long addr, size;
+    static int local_initialized = 0;
 #endif /* USE_DL */
-	int success = 0;	/* init not needed when SOLARIS_THREADS and */
-				/* C_THREADS implemented properly */
+    int success = 0;            /* init not needed when SOLARIS_THREADS and */
+                /* C_THREADS implemented properly */
 
-	dprintf(("PyThread_start_new_thread called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-	switch (ussetlock(count_lock)) {
-	case 0: return 0;
-	case -1: perror("ussetlock (count_lock)");
-	}
-	if (maxpidindex >= MAXPROC)
-		success = -1;
-	else {
+    dprintf(("PyThread_start_new_thread called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+    switch (ussetlock(count_lock)) {
+    case 0: return 0;
+    case -1: perror("ussetlock (count_lock)");
+    }
+    if (maxpidindex >= MAXPROC)
+        success = -1;
+    else {
 #ifdef USE_DL
-		if (!local_initialized) {
-			if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
-				perror("usconfig - CONF_INITSIZE (check)");
-			if (usconfig(CONF_INITSIZE, size) < 0)
-				perror("usconfig - CONF_INITSIZE (reset)");
-			addr = (long) dl_getrange(size + HDR_SIZE);
-			dprintf(("trying to use addr %p-%p for sproc\n",
-				 addr, addr+size));
-			errno = 0;
-			if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 &&
-			    errno != 0)
-				perror("usconfig - CONF_ATTACHADDR (set)");
-		}
+        if (!local_initialized) {
+            if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
+                perror("usconfig - CONF_INITSIZE (check)");
+            if (usconfig(CONF_INITSIZE, size) < 0)
+                perror("usconfig - CONF_INITSIZE (reset)");
+            addr = (long) dl_getrange(size + HDR_SIZE);
+            dprintf(("trying to use addr %p-%p for sproc\n",
+                     addr, addr+size));
+            errno = 0;
+            if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 &&
+                errno != 0)
+                perror("usconfig - CONF_ATTACHADDR (set)");
+        }
 #endif /* USE_DL */
-		clean_threads();
-		if ((success = sproc(func, PR_SALL, arg)) < 0)
-			perror("sproc");
+        clean_threads();
+        if ((success = sproc(func, PR_SALL, arg)) < 0)
+            perror("sproc");
 #ifdef USE_DL
-		if (!local_initialized) {
-			if (usconfig(CONF_ATTACHADDR, addr) < 0)
-				/* reset address */
-				perror("usconfig - CONF_ATTACHADDR (reset)");
-			local_initialized = 1;
-		}
+        if (!local_initialized) {
+            if (usconfig(CONF_ATTACHADDR, addr) < 0)
+                /* reset address */
+                perror("usconfig - CONF_ATTACHADDR (reset)");
+            local_initialized = 1;
+        }
 #endif /* USE_DL */
-		if (success >= 0) {
-			nthreads++;
-			pidlist[maxpidindex].parent = getpid();
-			pidlist[maxpidindex++].child = success;
-			dprintf(("pidlist[%d] = %d\n",
-				 maxpidindex-1, success));
-		}
-	}
-	if (usunsetlock(count_lock) < 0)
-		perror("usunsetlock (count_lock)");
-	return success;
+        if (success >= 0) {
+            nthreads++;
+            pidlist[maxpidindex].parent = getpid();
+            pidlist[maxpidindex++].child = success;
+            dprintf(("pidlist[%d] = %d\n",
+                     maxpidindex-1, success));
+        }
+    }
+    if (usunsetlock(count_lock) < 0)
+        perror("usunsetlock (count_lock)");
+    return success;
 }
 
 long PyThread_get_thread_ident(void)
 {
-	return getpid();
+    return getpid();
 }
 
 void PyThread_exit_thread(void)
 {
-	dprintf(("PyThread_exit_thread called\n"));
-	if (!initialized)
-		exit(0);
-	if (ussetlock(count_lock) < 0)
-		perror("ussetlock (count_lock)");
-	nthreads--;
-	if (getpid() == my_pid) {
-		/* main thread; wait for other threads to exit */
-		exiting = 1;
-		waiting_for_threads = 1;
-		if (ussetlock(wait_lock) < 0)
-			perror("ussetlock (wait_lock)");
-		for (;;) {
-			if (nthreads < 0) {
-				dprintf(("really exit (%d)\n", exit_status));
-				exit(exit_status);
-			}
-			if (usunsetlock(count_lock) < 0)
-				perror("usunsetlock (count_lock)");
-			dprintf(("waiting for other threads (%d)\n", nthreads));
-			if (ussetlock(wait_lock) < 0)
-				perror("ussetlock (wait_lock)");
-			if (ussetlock(count_lock) < 0)
-				perror("ussetlock (count_lock)");
-		}
-	}
-	/* not the main thread */
-	if (waiting_for_threads) {
-		dprintf(("main thread is waiting\n"));
-		if (usunsetlock(wait_lock) < 0)
-			perror("usunsetlock (wait_lock)");
-	}
-	if (usunsetlock(count_lock) < 0)
-		perror("usunsetlock (count_lock)");
-	_exit(0);
+    dprintf(("PyThread_exit_thread called\n"));
+    if (!initialized)
+        exit(0);
+    if (ussetlock(count_lock) < 0)
+        perror("ussetlock (count_lock)");
+    nthreads--;
+    if (getpid() == my_pid) {
+        /* main thread; wait for other threads to exit */
+        exiting = 1;
+        waiting_for_threads = 1;
+        if (ussetlock(wait_lock) < 0)
+            perror("ussetlock (wait_lock)");
+        for (;;) {
+            if (nthreads < 0) {
+                dprintf(("really exit (%d)\n", exit_status));
+                exit(exit_status);
+            }
+            if (usunsetlock(count_lock) < 0)
+                perror("usunsetlock (count_lock)");
+            dprintf(("waiting for other threads (%d)\n", nthreads));
+            if (ussetlock(wait_lock) < 0)
+                perror("ussetlock (wait_lock)");
+            if (ussetlock(count_lock) < 0)
+                perror("ussetlock (count_lock)");
+        }
+    }
+    /* not the main thread */
+    if (waiting_for_threads) {
+        dprintf(("main thread is waiting\n"));
+        if (usunsetlock(wait_lock) < 0)
+            perror("usunsetlock (wait_lock)");
+    }
+    if (usunsetlock(count_lock) < 0)
+        perror("usunsetlock (count_lock)");
+    _exit(0);
 }
 
 /*
@@ -216,44 +216,44 @@ void PyThread_exit_thread(void)
  */
 PyThread_type_lock PyThread_allocate_lock(void)
 {
-	ulock_t lock;
+    ulock_t lock;
 
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
 
-	if ((lock = usnewlock(shared_arena)) == NULL)
-		perror("usnewlock");
-	(void) usinitlock(lock);
-	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-	return (PyThread_type_lock) lock;
+    if ((lock = usnewlock(shared_arena)) == NULL)
+        perror("usnewlock");
+    (void) usinitlock(lock);
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock) lock;
 }
 
 void PyThread_free_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
-	usfreelock((ulock_t) lock, shared_arena);
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
+    usfreelock((ulock_t) lock, shared_arena);
 }
 
 int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 {
-	int success;
+    int success;
 
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-	errno = 0;		/* clear it just in case */
-	if (waitflag)
-		success = ussetlock((ulock_t) lock);
-	else
-		success = uscsetlock((ulock_t) lock, 1); /* Try it once */
-	if (success < 0)
-		perror(waitflag ? "ussetlock" : "uscsetlock");
-	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-	return success;
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+    errno = 0;                  /* clear it just in case */
+    if (waitflag)
+        success = ussetlock((ulock_t) lock);
+    else
+        success = uscsetlock((ulock_t) lock, 1); /* Try it once */
+    if (success < 0)
+        perror(waitflag ? "ussetlock" : "uscsetlock");
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
 }
 
 void PyThread_release_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_release_lock(%p) called\n", lock));
-	if (usunsetlock((ulock_t) lock) < 0)
-		perror("usunsetlock");
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
+    if (usunsetlock((ulock_t) lock) < 0)
+        perror("usunsetlock");
 }
diff --git a/Python/thread_solaris.h b/Python/thread_solaris.h
index 59ca002..1ce1cfc 100644
--- a/Python/thread_solaris.h
+++ b/Python/thread_solaris.h
@@ -17,114 +17,114 @@ static void PyThread__init_thread(void)
  * Thread support.
  */
 struct func_arg {
-	void (*func)(void *);
-	void *arg;
+    void (*func)(void *);
+    void *arg;
 };
 
 static void *
 new_func(void *funcarg)
 {
-	void (*func)(void *);
-	void *arg;
-
-	func = ((struct func_arg *) funcarg)->func;
-	arg = ((struct func_arg *) funcarg)->arg;
-	free(funcarg);
-	(*func)(arg);
-	return 0;
+    void (*func)(void *);
+    void *arg;
+
+    func = ((struct func_arg *) funcarg)->func;
+    arg = ((struct func_arg *) funcarg)->arg;
+    free(funcarg);
+    (*func)(arg);
+    return 0;
 }
 
 
 long
 PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-	thread_t tid;
-	struct func_arg *funcarg;
-
-	dprintf(("PyThread_start_new_thread called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-	funcarg = (struct func_arg *) malloc(sizeof(struct func_arg));
-	funcarg->func = func;
-	funcarg->arg = arg;
-	if (thr_create(0, 0, new_func, funcarg,
-		       THR_DETACHED | THR_NEW_LWP, &tid)) {
-		perror("thr_create");
-		free((void *) funcarg);
-		return -1;
-	}
-	return tid;
+    thread_t tid;
+    struct func_arg *funcarg;
+
+    dprintf(("PyThread_start_new_thread called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+    funcarg = (struct func_arg *) malloc(sizeof(struct func_arg));
+    funcarg->func = func;
+    funcarg->arg = arg;
+    if (thr_create(0, 0, new_func, funcarg,
+                   THR_DETACHED | THR_NEW_LWP, &tid)) {
+        perror("thr_create");
+        free((void *) funcarg);
+        return -1;
+    }
+    return tid;
 }
 
 long
 PyThread_get_thread_ident(void)
 {
-	if (!initialized)
-		PyThread_init_thread();
-	return thr_self();
+    if (!initialized)
+        PyThread_init_thread();
+    return thr_self();
 }
 
-void 
+void
 PyThread_exit_thread(void)
 {
-	dprintf(("PyThread_exit_thread called\n"));
-	if (!initialized)
-		exit(0);
-	thr_exit(0);
+    dprintf(("PyThread_exit_thread called\n"));
+    if (!initialized)
+        exit(0);
+    thr_exit(0);
 }
 
 /*
  * Lock support.
  */
-PyThread_type_lock 
+PyThread_type_lock
 PyThread_allocate_lock(void)
 {
-	mutex_t *lock;
-
-	dprintf(("PyThread_allocate_lock called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-
-	lock = (mutex_t *) malloc(sizeof(mutex_t));
-	if (mutex_init(lock, USYNC_THREAD, 0)) {
-		perror("mutex_init");
-		free((void *) lock);
-		lock = 0;
-	}
-	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-	return (PyThread_type_lock) lock;
+    mutex_t *lock;
+
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+
+    lock = (mutex_t *) malloc(sizeof(mutex_t));
+    if (mutex_init(lock, USYNC_THREAD, 0)) {
+        perror("mutex_init");
+        free((void *) lock);
+        lock = 0;
+    }
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock) lock;
 }
 
-void 
+void
 PyThread_free_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_free_lock(%p) called\n", lock));
-	mutex_destroy((mutex_t *) lock);
-	free((void *) lock);
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
+    mutex_destroy((mutex_t *) lock);
+    free((void *) lock);
 }
 
-int 
+int
 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 {
-	int success;
-
-	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-	if (waitflag)
-		success = mutex_lock((mutex_t *) lock);
-	else
-		success = mutex_trylock((mutex_t *) lock);
-	if (success < 0)
-		perror(waitflag ? "mutex_lock" : "mutex_trylock");
-	else
-		success = !success; /* solaris does it the other way round */
-	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-	return success;
+    int success;
+
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+    if (waitflag)
+        success = mutex_lock((mutex_t *) lock);
+    else
+        success = mutex_trylock((mutex_t *) lock);
+    if (success < 0)
+        perror(waitflag ? "mutex_lock" : "mutex_trylock");
+    else
+        success = !success; /* solaris does it the other way round */
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
 }
 
-void 
+void
 PyThread_release_lock(PyThread_type_lock lock)
 {
-	dprintf(("PyThread_release_lock(%p) called\n", lock));
-	if (mutex_unlock((mutex_t *) lock))
-		perror("mutex_unlock");
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
+    if (mutex_unlock((mutex_t *) lock))
+        perror("mutex_unlock");
 }
diff --git a/Python/thread_wince.h b/Python/thread_wince.h
index f8cf2cf..51ddc02 100644
--- a/Python/thread_wince.h
+++ b/Python/thread_wince.h
@@ -24,21 +24,21 @@ static void PyThread__init_thread(void)
  */
 long PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-	long rv;
-	int success = -1;
+    long rv;
+    int success = -1;
 
-	dprintf(("%ld: PyThread_start_new_thread called\n", PyThread_get_thread_ident()));
-	if (!initialized)
-		PyThread_init_thread();
+    dprintf(("%ld: PyThread_start_new_thread called\n", PyThread_get_thread_ident()));
+    if (!initialized)
+        PyThread_init_thread();
 
-	rv = _beginthread(func, 0, arg); /* use default stack size */
- 
-	if (rv != -1) {
-		success = 0;
-		dprintf(("%ld: PyThread_start_new_thread succeeded:\n", PyThread_get_thread_ident()));
-	}
+    rv = _beginthread(func, 0, arg); /* use default stack size */
 
-	return success;
+    if (rv != -1) {
+        success = 0;
+        dprintf(("%ld: PyThread_start_new_thread succeeded:\n", PyThread_get_thread_ident()));
+    }
+
+    return success;
 }
 
 /*
@@ -47,18 +47,18 @@ long PyThread_start_new_thread(void (*func)(void *), void *arg)
  */
 long PyThread_get_thread_ident(void)
 {
-	if (!initialized)
-		PyThread_init_thread();
-        
-	return GetCurrentThreadId();
+    if (!initialized)
+        PyThread_init_thread();
+
+    return GetCurrentThreadId();
 }
 
 void PyThread_exit_thread(void)
 {
-	dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
-	if (!initialized)
-		exit(0);
-	_endthread();
+    dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
+    if (!initialized)
+        exit(0);
+    _endthread();
 }
 
 /*
@@ -72,12 +72,12 @@ PyThread_type_lock PyThread_allocate_lock(void)
 
     dprintf(("PyThread_allocate_lock called\n"));
     if (!initialized)
-        PyThread_init_thread();
+    PyThread_init_thread();
 
     aLock = CreateEvent(NULL,           /* Security attributes      */
-                        0,              /* Manual-Reset               */
-						1,              /* Is initially signalled  */
-                        NULL);          /* Name of event            */
+            0,              /* Manual-Reset               */
+                        1,              /* Is initially signalled  */
+            NULL);          /* Name of event            */
 
     dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
 
@@ -107,22 +107,22 @@ int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
 #ifndef DEBUG
     waitResult = WaitForSingleObject(aLock, (waitflag ? INFINITE : 0));
 #else
-	/* To aid in debugging, we regularly wake up.  This allows us to
-	break into the debugger */
-	while (TRUE) {
-		waitResult = WaitForSingleObject(aLock, waitflag ? 3000 : 0);
-		if (waitflag==0 || (waitflag && waitResult == WAIT_OBJECT_0))
-			break;
-	}
+    /* To aid in debugging, we regularly wake up.  This allows us to
+    break into the debugger */
+    while (TRUE) {
+        waitResult = WaitForSingleObject(aLock, waitflag ? 3000 : 0);
+        if (waitflag==0 || (waitflag && waitResult == WAIT_OBJECT_0))
+            break;
+    }
 #endif
 
     if (waitResult != WAIT_OBJECT_0) {
-		success = 0;    /* We failed */
+                success = 0;    /* We failed */
     }
 
-	dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
+    dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
 
-	return success;
+    return success;
 }
 
 void PyThread_release_lock(PyThread_type_lock aLock)
@@ -130,7 +130,7 @@ void PyThread_release_lock(PyThread_type_lock aLock)
     dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 
     if (!SetEvent(aLock))
-        dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
+    dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
 }
 
 
diff --git a/Python/traceback.c b/Python/traceback.c
index 53491ee..adfd66c 100644
--- a/Python/traceback.c
+++ b/Python/traceback.c
@@ -12,272 +12,272 @@
 #define OFF(x) offsetof(PyTracebackObject, x)
 
 static PyMemberDef tb_memberlist[] = {
-	{"tb_next",	T_OBJECT,	OFF(tb_next), READONLY},
-	{"tb_frame",	T_OBJECT,	OFF(tb_frame), READONLY},
-	{"tb_lasti",	T_INT,		OFF(tb_lasti), READONLY},
-	{"tb_lineno",	T_INT,		OFF(tb_lineno), READONLY},
-	{NULL}	/* Sentinel */
+    {"tb_next",         T_OBJECT,       OFF(tb_next), READONLY},
+    {"tb_frame",        T_OBJECT,       OFF(tb_frame), READONLY},
+    {"tb_lasti",        T_INT,          OFF(tb_lasti), READONLY},
+    {"tb_lineno",       T_INT,          OFF(tb_lineno), READONLY},
+    {NULL}      /* Sentinel */
 };
 
 static void
 tb_dealloc(PyTracebackObject *tb)
 {
-	PyObject_GC_UnTrack(tb);
-	Py_TRASHCAN_SAFE_BEGIN(tb)
-	Py_XDECREF(tb->tb_next);
-	Py_XDECREF(tb->tb_frame);
-	PyObject_GC_Del(tb);
-	Py_TRASHCAN_SAFE_END(tb)
+    PyObject_GC_UnTrack(tb);
+    Py_TRASHCAN_SAFE_BEGIN(tb)
+    Py_XDECREF(tb->tb_next);
+    Py_XDECREF(tb->tb_frame);
+    PyObject_GC_Del(tb);
+    Py_TRASHCAN_SAFE_END(tb)
 }
 
 static int
 tb_traverse(PyTracebackObject *tb, visitproc visit, void *arg)
 {
-	Py_VISIT(tb->tb_next);
-	Py_VISIT(tb->tb_frame);
-	return 0;
+    Py_VISIT(tb->tb_next);
+    Py_VISIT(tb->tb_frame);
+    return 0;
 }
 
 static void
 tb_clear(PyTracebackObject *tb)
 {
-	Py_CLEAR(tb->tb_next);
-	Py_CLEAR(tb->tb_frame);
+    Py_CLEAR(tb->tb_next);
+    Py_CLEAR(tb->tb_frame);
 }
 
 PyTypeObject PyTraceBack_Type = {
-	PyVarObject_HEAD_INIT(&PyType_Type, 0)
-	"traceback",
-	sizeof(PyTracebackObject),
-	0,
-	(destructor)tb_dealloc, /*tp_dealloc*/
-	0,		/*tp_print*/
-	0,              /*tp_getattr*/
-	0,		/*tp_setattr*/
-	0,		/*tp_compare*/
-	0,		/*tp_repr*/
-	0,		/*tp_as_number*/
-	0,		/*tp_as_sequence*/
-	0,		/*tp_as_mapping*/
-	0,		/* tp_hash */
-	0,		/* tp_call */
-	0,		/* tp_str */
-	0,		/* tp_getattro */
-	0,		/* tp_setattro */
-	0,					/* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
-	0,             				/* tp_doc */
- 	(traverseproc)tb_traverse,		/* tp_traverse */
-	(inquiry)tb_clear,			/* tp_clear */
-	0,					/* tp_richcompare */
-	0,					/* tp_weaklistoffset */
-	0,					/* tp_iter */
-	0,					/* tp_iternext */
-	0,					/* tp_methods */
-	tb_memberlist,			        /* tp_members */
-	0,			                /* tp_getset */
-	0,					/* tp_base */
-	0,					/* tp_dict */
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
+    "traceback",
+    sizeof(PyTracebackObject),
+    0,
+    (destructor)tb_dealloc, /*tp_dealloc*/
+    0,                  /*tp_print*/
+    0,              /*tp_getattr*/
+    0,                  /*tp_setattr*/
+    0,                  /*tp_compare*/
+    0,                  /*tp_repr*/
+    0,                  /*tp_as_number*/
+    0,                  /*tp_as_sequence*/
+    0,                  /*tp_as_mapping*/
+    0,                  /* tp_hash */
+    0,                  /* tp_call */
+    0,                  /* tp_str */
+    0,                  /* tp_getattro */
+    0,                  /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
+    0,                                          /* tp_doc */
+    (traverseproc)tb_traverse,                  /* tp_traverse */
+    (inquiry)tb_clear,                          /* tp_clear */
+    0,                                          /* tp_richcompare */
+    0,                                          /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    0,                                          /* tp_methods */
+    tb_memberlist,                              /* tp_members */
+    0,                                          /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
 };
 
 static PyTracebackObject *
 newtracebackobject(PyTracebackObject *next, PyFrameObject *frame)
 {
-	PyTracebackObject *tb;
-	if ((next != NULL && !PyTraceBack_Check(next)) ||
-			frame == NULL || !PyFrame_Check(frame)) {
-		PyErr_BadInternalCall();
-		return NULL;
-	}
-	tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type);
-	if (tb != NULL) {
-		Py_XINCREF(next);
-		tb->tb_next = next;
-		Py_XINCREF(frame);
-		tb->tb_frame = frame;
-		tb->tb_lasti = frame->f_lasti;
-		tb->tb_lineno = PyFrame_GetLineNumber(frame);
-		PyObject_GC_Track(tb);
-	}
-	return tb;
+    PyTracebackObject *tb;
+    if ((next != NULL && !PyTraceBack_Check(next)) ||
+                    frame == NULL || !PyFrame_Check(frame)) {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+    tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type);
+    if (tb != NULL) {
+        Py_XINCREF(next);
+        tb->tb_next = next;
+        Py_XINCREF(frame);
+        tb->tb_frame = frame;
+        tb->tb_lasti = frame->f_lasti;
+        tb->tb_lineno = PyFrame_GetLineNumber(frame);
+        PyObject_GC_Track(tb);
+    }
+    return tb;
 }
 
 int
 PyTraceBack_Here(PyFrameObject *frame)
 {
-	PyThreadState *tstate = PyThreadState_GET();
-	PyTracebackObject *oldtb = (PyTracebackObject *) tstate->curexc_traceback;
-	PyTracebackObject *tb = newtracebackobject(oldtb, frame);
-	if (tb == NULL)
-		return -1;
-	tstate->curexc_traceback = (PyObject *)tb;
-	Py_XDECREF(oldtb);
-	return 0;
+    PyThreadState *tstate = PyThreadState_GET();
+    PyTracebackObject *oldtb = (PyTracebackObject *) tstate->curexc_traceback;
+    PyTracebackObject *tb = newtracebackobject(oldtb, frame);
+    if (tb == NULL)
+        return -1;
+    tstate->curexc_traceback = (PyObject *)tb;
+    Py_XDECREF(oldtb);
+    return 0;
 }
 
 int
 _Py_DisplaySourceLine(PyObject *f, const char *filename, int lineno, int indent)
 {
-	int err = 0;
-	FILE *xfp = NULL;
-	char linebuf[2000];
-	int i;
-	char namebuf[MAXPATHLEN+1];
+    int err = 0;
+    FILE *xfp = NULL;
+    char linebuf[2000];
+    int i;
+    char namebuf[MAXPATHLEN+1];
 
-	if (filename == NULL)
-		return -1;
-	/* This is needed by Emacs' compile command */
+    if (filename == NULL)
+        return -1;
+    /* This is needed by Emacs' compile command */
 #define FMT "  File \"%.500s\", line %d, in %.500s\n"
-	xfp = fopen(filename, "r" PY_STDIOTEXTMODE);
-	if (xfp == NULL) {
-		/* Search tail of filename in sys.path before giving up */
-		PyObject *path;
-		const char *tail = strrchr(filename, SEP);
-		if (tail == NULL)
-			tail = filename;
-		else
-			tail++;
-		path = PySys_GetObject("path");
-		if (path != NULL && PyList_Check(path)) {
-			Py_ssize_t _npath = PyList_Size(path);
-			int npath = Py_SAFE_DOWNCAST(_npath, Py_ssize_t, int);
-			size_t taillen = strlen(tail);
-			for (i = 0; i < npath; i++) {
-				PyObject *v = PyList_GetItem(path, i);
-				if (v == NULL) {
-					PyErr_Clear();
-					break;
-				}
-				if (PyString_Check(v)) {
-					size_t len;
-					len = PyString_GET_SIZE(v);
-					if (len + 1 + taillen >= MAXPATHLEN)
-						continue; /* Too long */
-					strcpy(namebuf, PyString_AsString(v));
-					if (strlen(namebuf) != len)
-						continue; /* v contains '\0' */
-					if (len > 0 && namebuf[len-1] != SEP)
-						namebuf[len++] = SEP;
-					strcpy(namebuf+len, tail);
-					xfp = fopen(namebuf, "r" PY_STDIOTEXTMODE);
-					if (xfp != NULL) {
-						break;
-					}
-				}
-			}
-		}
-	}
-
-        if (xfp == NULL)
-            return err;
-        if (err != 0) {
-            fclose(xfp);
-            return err;
+    xfp = fopen(filename, "r" PY_STDIOTEXTMODE);
+    if (xfp == NULL) {
+        /* Search tail of filename in sys.path before giving up */
+        PyObject *path;
+        const char *tail = strrchr(filename, SEP);
+        if (tail == NULL)
+            tail = filename;
+        else
+            tail++;
+        path = PySys_GetObject("path");
+        if (path != NULL && PyList_Check(path)) {
+            Py_ssize_t _npath = PyList_Size(path);
+            int npath = Py_SAFE_DOWNCAST(_npath, Py_ssize_t, int);
+            size_t taillen = strlen(tail);
+            for (i = 0; i < npath; i++) {
+                PyObject *v = PyList_GetItem(path, i);
+                if (v == NULL) {
+                    PyErr_Clear();
+                    break;
+                }
+                if (PyString_Check(v)) {
+                    size_t len;
+                    len = PyString_GET_SIZE(v);
+                    if (len + 1 + taillen >= MAXPATHLEN)
+                        continue; /* Too long */
+                    strcpy(namebuf, PyString_AsString(v));
+                    if (strlen(namebuf) != len)
+                        continue; /* v contains '\0' */
+                    if (len > 0 && namebuf[len-1] != SEP)
+                        namebuf[len++] = SEP;
+                    strcpy(namebuf+len, tail);
+                    xfp = fopen(namebuf, "r" PY_STDIOTEXTMODE);
+                    if (xfp != NULL) {
+                        break;
+                    }
+                }
+            }
         }
+    }
+
+    if (xfp == NULL)
+        return err;
+    if (err != 0) {
+        fclose(xfp);
+        return err;
+    }
 
-	for (i = 0; i < lineno; i++) {
-		char* pLastChar = &linebuf[sizeof(linebuf)-2];
-		do {
-			*pLastChar = '\0';
-			if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, xfp, NULL) == NULL)
-				break;
-			/* fgets read *something*; if it didn't get as
-			   far as pLastChar, it must have found a newline
-			   or hit the end of the file;	if pLastChar is \n,
-			   it obviously found a newline; else we haven't
-			   yet seen a newline, so must continue */
-		} while (*pLastChar != '\0' && *pLastChar != '\n');
-	}
-	if (i == lineno) {
-		char buf[11];
-		char *p = linebuf;
-		while (*p == ' ' || *p == '\t' || *p == '\014')
-			p++;
+    for (i = 0; i < lineno; i++) {
+        char* pLastChar = &linebuf[sizeof(linebuf)-2];
+        do {
+            *pLastChar = '\0';
+            if (Py_UniversalNewlineFgets(linebuf, sizeof linebuf, xfp, NULL) == NULL)
+                break;
+            /* fgets read *something*; if it didn't get as
+               far as pLastChar, it must have found a newline
+               or hit the end of the file;              if pLastChar is \n,
+               it obviously found a newline; else we haven't
+               yet seen a newline, so must continue */
+        } while (*pLastChar != '\0' && *pLastChar != '\n');
+    }
+    if (i == lineno) {
+        char buf[11];
+        char *p = linebuf;
+        while (*p == ' ' || *p == '\t' || *p == '\014')
+            p++;
 
-		/* Write some spaces before the line */
-		strcpy(buf, "          ");
-		assert (strlen(buf) == 10);
-		while (indent > 0) {
-			if(indent < 10)
-				buf[indent] = '\0';
-			err = PyFile_WriteString(buf, f);
-			if (err != 0)
-				break;
-			indent -= 10;
-		}
+        /* Write some spaces before the line */
+        strcpy(buf, "          ");
+        assert (strlen(buf) == 10);
+        while (indent > 0) {
+            if(indent < 10)
+                buf[indent] = '\0';
+            err = PyFile_WriteString(buf, f);
+            if (err != 0)
+                break;
+            indent -= 10;
+        }
 
-		if (err == 0)
-			err = PyFile_WriteString(p, f);
-		if (err == 0 && strchr(p, '\n') == NULL)
-			err = PyFile_WriteString("\n", f);
-	}
-	fclose(xfp);
-	return err;
+        if (err == 0)
+            err = PyFile_WriteString(p, f);
+        if (err == 0 && strchr(p, '\n') == NULL)
+            err = PyFile_WriteString("\n", f);
+    }
+    fclose(xfp);
+    return err;
 }
 
 static int
 tb_displayline(PyObject *f, const char *filename, int lineno, const char *name)
 {
-	int err = 0;
-        char linebuf[2000];
+    int err = 0;
+    char linebuf[2000];
 
-	if (filename == NULL || name == NULL)
-		return -1;
-	/* This is needed by Emacs' compile command */
+    if (filename == NULL || name == NULL)
+        return -1;
+    /* This is needed by Emacs' compile command */
 #define FMT "  File \"%.500s\", line %d, in %.500s\n"
-	PyOS_snprintf(linebuf, sizeof(linebuf), FMT, filename, lineno, name);
-	err = PyFile_WriteString(linebuf, f);
-	if (err != 0)
-		return err;
-        return _Py_DisplaySourceLine(f, filename, lineno, 4);
+    PyOS_snprintf(linebuf, sizeof(linebuf), FMT, filename, lineno, name);
+    err = PyFile_WriteString(linebuf, f);
+    if (err != 0)
+        return err;
+    return _Py_DisplaySourceLine(f, filename, lineno, 4);
 }
 
 static int
 tb_printinternal(PyTracebackObject *tb, PyObject *f, long limit)
 {
-	int err = 0;
-	long depth = 0;
-	PyTracebackObject *tb1 = tb;
-	while (tb1 != NULL) {
-		depth++;
-		tb1 = tb1->tb_next;
-	}
-	while (tb != NULL && err == 0) {
-		if (depth <= limit) {
-			err = tb_displayline(f,
-			    PyString_AsString(
-				    tb->tb_frame->f_code->co_filename),
-			    tb->tb_lineno,
-			    PyString_AsString(tb->tb_frame->f_code->co_name));
-		}
-		depth--;
-		tb = tb->tb_next;
-		if (err == 0)
-			err = PyErr_CheckSignals();
-	}
-	return err;
+    int err = 0;
+    long depth = 0;
+    PyTracebackObject *tb1 = tb;
+    while (tb1 != NULL) {
+        depth++;
+        tb1 = tb1->tb_next;
+    }
+    while (tb != NULL && err == 0) {
+        if (depth <= limit) {
+            err = tb_displayline(f,
+                PyString_AsString(
+                    tb->tb_frame->f_code->co_filename),
+                tb->tb_lineno,
+                PyString_AsString(tb->tb_frame->f_code->co_name));
+        }
+        depth--;
+        tb = tb->tb_next;
+        if (err == 0)
+            err = PyErr_CheckSignals();
+    }
+    return err;
 }
 
 int
 PyTraceBack_Print(PyObject *v, PyObject *f)
 {
-	int err;
-	PyObject *limitv;
-	long limit = 1000;
-	if (v == NULL)
-		return 0;
-	if (!PyTraceBack_Check(v)) {
-		PyErr_BadInternalCall();
-		return -1;
-	}
-	limitv = PySys_GetObject("tracebacklimit");
-	if (limitv && PyInt_Check(limitv)) {
-		limit = PyInt_AsLong(limitv);
-		if (limit <= 0)
-			return 0;
-	}
-	err = PyFile_WriteString("Traceback (most recent call last):\n", f);
-	if (!err)
-		err = tb_printinternal((PyTracebackObject *)v, f, limit);
-	return err;
+    int err;
+    PyObject *limitv;
+    long limit = 1000;
+    if (v == NULL)
+        return 0;
+    if (!PyTraceBack_Check(v)) {
+        PyErr_BadInternalCall();
+        return -1;
+    }
+    limitv = PySys_GetObject("tracebacklimit");
+    if (limitv && PyInt_Check(limitv)) {
+        limit = PyInt_AsLong(limitv);
+        if (limit <= 0)
+            return 0;
+    }
+    err = PyFile_WriteString("Traceback (most recent call last):\n", f);
+    if (!err)
+        err = tb_printinternal((PyTracebackObject *)v, f, limit);
+    return err;
 }