diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c
index 9acd7f7..ee89006 100644
--- a/Objects/sliceobject.c
+++ b/Objects/sliceobject.c
@@ -7,7 +7,7 @@
 for this file.
 */
 
-/* 
+/*
 Py_Ellipsis encodes the '...' rubber index token. It is similar to
 the Py_NoneStruct in that there is no way to create other objects of
 this type and there is exactly one in existence.
@@ -19,35 +19,35 @@
 static PyObject *
 ellipsis_repr(PyObject *op)
 {
-	return PyUnicode_FromString("Ellipsis");
+    return PyUnicode_FromString("Ellipsis");
 }
 
 PyTypeObject PyEllipsis_Type = {
-	PyVarObject_HEAD_INIT(&PyType_Type, 0)
-	"ellipsis",			/* tp_name */
-	0,				/* tp_basicsize */
-	0,				/* tp_itemsize */
-	0, /*never called*/		/* tp_dealloc */
-	0,				/* tp_print */
-	0,				/* tp_getattr */
-	0,				/* tp_setattr */
-	0,				/* tp_reserved */
-	ellipsis_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 */
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
+    "ellipsis",                         /* tp_name */
+    0,                                  /* tp_basicsize */
+    0,                                  /* tp_itemsize */
+    0, /*never called*/                 /* tp_dealloc */
+    0,                                  /* tp_print */
+    0,                                  /* tp_getattr */
+    0,                                  /* tp_setattr */
+    0,                                  /* tp_reserved */
+    ellipsis_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 */
 };
 
 PyObject _Py_EllipsisObject = {
-	_PyObject_EXTRA_INIT
-	1, &PyEllipsis_Type
+    _PyObject_EXTRA_INIT
+    1, &PyEllipsis_Type
 };
 
 
@@ -60,154 +60,154 @@
 PyObject *
 PySlice_New(PyObject *start, PyObject *stop, PyObject *step)
 {
-	PySliceObject *obj = PyObject_New(PySliceObject, &PySlice_Type);
+    PySliceObject *obj = PyObject_New(PySliceObject, &PySlice_Type);
 
-	if (obj == NULL)
-		return NULL;
+    if (obj == NULL)
+        return NULL;
 
-	if (step == NULL) step = Py_None;
-	Py_INCREF(step);
-	if (start == NULL) start = Py_None;
-	Py_INCREF(start);
-	if (stop == NULL) stop = Py_None;
-	Py_INCREF(stop);
+    if (step == NULL) step = Py_None;
+    Py_INCREF(step);
+    if (start == NULL) start = Py_None;
+    Py_INCREF(start);
+    if (stop == NULL) stop = Py_None;
+    Py_INCREF(stop);
 
-	obj->step = step;
-	obj->start = start;
-	obj->stop = stop;
+    obj->step = step;
+    obj->start = start;
+    obj->stop = stop;
 
-	return (PyObject *) obj;
+    return (PyObject *) obj;
 }
 
 PyObject *
 _PySlice_FromIndices(Py_ssize_t istart, Py_ssize_t istop)
 {
-	PyObject *start, *end, *slice;
-	start = PyLong_FromSsize_t(istart);
-	if (!start)
-		return NULL;
-	end = PyLong_FromSsize_t(istop);
-	if (!end) {
-		Py_DECREF(start);
-		return NULL;
-	}
+    PyObject *start, *end, *slice;
+    start = PyLong_FromSsize_t(istart);
+    if (!start)
+        return NULL;
+    end = PyLong_FromSsize_t(istop);
+    if (!end) {
+        Py_DECREF(start);
+        return NULL;
+    }
 
-	slice = PySlice_New(start, end, NULL);
-	Py_DECREF(start);
-	Py_DECREF(end);
-	return slice;
+    slice = PySlice_New(start, end, NULL);
+    Py_DECREF(start);
+    Py_DECREF(end);
+    return slice;
 }
 
 int
 PySlice_GetIndices(PySliceObject *r, Py_ssize_t length,
                    Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step)
 {
-	/* XXX support long ints */
-	if (r->step == Py_None) {
-		*step = 1;
-	} else {
-		if (!PyLong_Check(r->step)) return -1;
-		*step = PyLong_AsSsize_t(r->step);
-	}
-	if (r->start == Py_None) {
-		*start = *step < 0 ? length-1 : 0;
-	} else {
-		if (!PyLong_Check(r->start)) return -1;
-		*start = PyLong_AsSsize_t(r->start);
-		if (*start < 0) *start += length;
-	}
-	if (r->stop == Py_None) {
-		*stop = *step < 0 ? -1 : length;
-	} else {
-		if (!PyLong_Check(r->stop)) return -1;
-		*stop = PyLong_AsSsize_t(r->stop);
-		if (*stop < 0) *stop += length;
-	}
-	if (*stop > length) return -1;
-	if (*start >= length) return -1;
-	if (*step == 0) return -1;
-	return 0;
+    /* XXX support long ints */
+    if (r->step == Py_None) {
+        *step = 1;
+    } else {
+        if (!PyLong_Check(r->step)) return -1;
+        *step = PyLong_AsSsize_t(r->step);
+    }
+    if (r->start == Py_None) {
+        *start = *step < 0 ? length-1 : 0;
+    } else {
+        if (!PyLong_Check(r->start)) return -1;
+        *start = PyLong_AsSsize_t(r->start);
+        if (*start < 0) *start += length;
+    }
+    if (r->stop == Py_None) {
+        *stop = *step < 0 ? -1 : length;
+    } else {
+        if (!PyLong_Check(r->stop)) return -1;
+        *stop = PyLong_AsSsize_t(r->stop);
+        if (*stop < 0) *stop += length;
+    }
+    if (*stop > length) return -1;
+    if (*start >= length) return -1;
+    if (*step == 0) return -1;
+    return 0;
 }
 
 int
 PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length,
-		     Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, Py_ssize_t *slicelength)
+                     Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, Py_ssize_t *slicelength)
 {
-	/* this is harder to get right than you might think */
+    /* this is harder to get right than you might think */
 
-	Py_ssize_t defstart, defstop;
+    Py_ssize_t defstart, defstop;
 
-	if (r->step == Py_None) {
-		*step = 1;
-	} 
-	else {
-		if (!_PyEval_SliceIndex(r->step, step)) return -1;
-		if (*step == 0) {
-			PyErr_SetString(PyExc_ValueError,
-					"slice step cannot be zero");
-			return -1;
-		}
-	}
+    if (r->step == Py_None) {
+        *step = 1;
+    }
+    else {
+        if (!_PyEval_SliceIndex(r->step, step)) return -1;
+        if (*step == 0) {
+            PyErr_SetString(PyExc_ValueError,
+                            "slice step cannot be zero");
+            return -1;
+        }
+    }
 
-	defstart = *step < 0 ? length-1 : 0;
-	defstop = *step < 0 ? -1 : length;
+    defstart = *step < 0 ? length-1 : 0;
+    defstop = *step < 0 ? -1 : length;
 
-	if (r->start == Py_None) {
-		*start = defstart;
-	}
-	else {
-		if (!_PyEval_SliceIndex(r->start, start)) return -1;
-		if (*start < 0) *start += length;
-		if (*start < 0) *start = (*step < 0) ? -1 : 0;
-		if (*start >= length) 
-			*start = (*step < 0) ? length - 1 : length;
-	}
+    if (r->start == Py_None) {
+        *start = defstart;
+    }
+    else {
+        if (!_PyEval_SliceIndex(r->start, start)) return -1;
+        if (*start < 0) *start += length;
+        if (*start < 0) *start = (*step < 0) ? -1 : 0;
+        if (*start >= length)
+            *start = (*step < 0) ? length - 1 : length;
+    }
 
-	if (r->stop == Py_None) {
-		*stop = defstop;
-	}
-	else {
-		if (!_PyEval_SliceIndex(r->stop, stop)) return -1;
-		if (*stop < 0) *stop += length;
-		if (*stop < 0) *stop = (*step < 0) ? -1 : 0;
-		if (*stop >= length)
-			*stop = (*step < 0) ? length - 1 : length;
-	}
+    if (r->stop == Py_None) {
+        *stop = defstop;
+    }
+    else {
+        if (!_PyEval_SliceIndex(r->stop, stop)) return -1;
+        if (*stop < 0) *stop += length;
+        if (*stop < 0) *stop = (*step < 0) ? -1 : 0;
+        if (*stop >= length)
+            *stop = (*step < 0) ? length - 1 : length;
+    }
 
-	if ((*step < 0 && *stop >= *start) 
-	    || (*step > 0 && *start >= *stop)) {
-		*slicelength = 0;
-	}
-	else if (*step < 0) {
-		*slicelength = (*stop-*start+1)/(*step)+1;
-	}
-	else {
-		*slicelength = (*stop-*start-1)/(*step)+1;
-	}
+    if ((*step < 0 && *stop >= *start)
+        || (*step > 0 && *start >= *stop)) {
+        *slicelength = 0;
+    }
+    else if (*step < 0) {
+        *slicelength = (*stop-*start+1)/(*step)+1;
+    }
+    else {
+        *slicelength = (*stop-*start-1)/(*step)+1;
+    }
 
-	return 0;
+    return 0;
 }
 
 static PyObject *
 slice_new(PyTypeObject *type, PyObject *args, PyObject *kw)
 {
-	PyObject *start, *stop, *step;
+    PyObject *start, *stop, *step;
 
-	start = stop = step = NULL;
+    start = stop = step = NULL;
 
-	if (!_PyArg_NoKeywords("slice()", kw))
-		return NULL;
+    if (!_PyArg_NoKeywords("slice()", kw))
+        return NULL;
 
-	if (!PyArg_UnpackTuple(args, "slice", 1, 3, &start, &stop, &step))
-		return NULL;
+    if (!PyArg_UnpackTuple(args, "slice", 1, 3, &start, &stop, &step))
+        return NULL;
 
-	/* This swapping of stop and start is to maintain similarity with
-	   range(). */
-	if (stop == NULL) {
-		stop = start;
-		start = NULL;
-	}
-	return PySlice_New(start, stop, step);
+    /* This swapping of stop and start is to maintain similarity with
+       range(). */
+    if (stop == NULL) {
+        stop = start;
+        start = NULL;
+    }
+    return PySlice_New(start, stop, step);
 }
 
 PyDoc_STRVAR(slice_doc,
@@ -218,42 +218,42 @@
 static void
 slice_dealloc(PySliceObject *r)
 {
-	Py_DECREF(r->step);
-	Py_DECREF(r->start);
-	Py_DECREF(r->stop);
-	PyObject_Del(r);
+    Py_DECREF(r->step);
+    Py_DECREF(r->start);
+    Py_DECREF(r->stop);
+    PyObject_Del(r);
 }
 
 static PyObject *
 slice_repr(PySliceObject *r)
 {
-	return PyUnicode_FromFormat("slice(%R, %R, %R)", r->start, r->stop, r->step);
+    return PyUnicode_FromFormat("slice(%R, %R, %R)", r->start, r->stop, r->step);
 }
 
 static PyMemberDef slice_members[] = {
-	{"start", T_OBJECT, offsetof(PySliceObject, start), READONLY},
-	{"stop", T_OBJECT, offsetof(PySliceObject, stop), READONLY},
-	{"step", T_OBJECT, offsetof(PySliceObject, step), READONLY},
-	{0}
+    {"start", T_OBJECT, offsetof(PySliceObject, start), READONLY},
+    {"stop", T_OBJECT, offsetof(PySliceObject, stop), READONLY},
+    {"step", T_OBJECT, offsetof(PySliceObject, step), READONLY},
+    {0}
 };
 
 static PyObject*
 slice_indices(PySliceObject* self, PyObject* len)
 {
-	Py_ssize_t ilen, start, stop, step, slicelength;
+    Py_ssize_t ilen, start, stop, step, slicelength;
 
-	ilen = PyNumber_AsSsize_t(len, PyExc_OverflowError);
+    ilen = PyNumber_AsSsize_t(len, PyExc_OverflowError);
 
-	if (ilen == -1 && PyErr_Occurred()) {
-		return NULL;
-	}
+    if (ilen == -1 && PyErr_Occurred()) {
+        return NULL;
+    }
 
-	if (PySlice_GetIndicesEx(self, ilen, &start, &stop, 
-				 &step, &slicelength) < 0) {
-		return NULL;
-	}
+    if (PySlice_GetIndicesEx(self, ilen, &start, &stop,
+                             &step, &slicelength) < 0) {
+        return NULL;
+    }
 
-	return Py_BuildValue("(nnn)", start, stop, step);
+    return Py_BuildValue("(nnn)", start, stop, step);
 }
 
 PyDoc_STRVAR(slice_indices_doc,
@@ -267,119 +267,119 @@
 static PyObject *
 slice_reduce(PySliceObject* self)
 {
-	return Py_BuildValue("O(OOO)", Py_TYPE(self), self->start, self->stop, self->step);
+    return Py_BuildValue("O(OOO)", Py_TYPE(self), self->start, self->stop, self->step);
 }
 
 PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
 
 static PyMethodDef slice_methods[] = {
-	{"indices",	(PyCFunction)slice_indices,
-	 METH_O,	slice_indices_doc},
-	{"__reduce__",	(PyCFunction)slice_reduce,
-	 METH_NOARGS,	reduce_doc},
-	{NULL, NULL}
+    {"indices",         (PyCFunction)slice_indices,
+     METH_O,            slice_indices_doc},
+    {"__reduce__",      (PyCFunction)slice_reduce,
+     METH_NOARGS,       reduce_doc},
+    {NULL, NULL}
 };
 
 static PyObject *
 slice_richcompare(PyObject *v, PyObject *w, int op)
 {
-	PyObject *t1;
-	PyObject *t2;
-	PyObject *res;
+    PyObject *t1;
+    PyObject *t2;
+    PyObject *res;
 
-	if (!PySlice_Check(v) || !PySlice_Check(w)) {
-		Py_INCREF(Py_NotImplemented);
-		return Py_NotImplemented;
-	}
+    if (!PySlice_Check(v) || !PySlice_Check(w)) {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
 
-	if (v == w) {
-		/* XXX Do we really need this shortcut?
-		   There's a unit test for it, but is that fair? */
-		switch (op) {
-		case Py_EQ: 
-		case Py_LE:
-		case Py_GE:
-			res = Py_True; 
-			break;
-		default:
-			res = Py_False; 
-			break;
-		}
-		Py_INCREF(res);
-		return res;
-	}
+    if (v == w) {
+        /* XXX Do we really need this shortcut?
+           There's a unit test for it, but is that fair? */
+        switch (op) {
+        case Py_EQ:
+        case Py_LE:
+        case Py_GE:
+            res = Py_True;
+            break;
+        default:
+            res = Py_False;
+            break;
+        }
+        Py_INCREF(res);
+        return res;
+    }
 
-	t1 = PyTuple_New(3);
-	t2 = PyTuple_New(3);
-	if (t1 == NULL || t2 == NULL)
-		return NULL;
+    t1 = PyTuple_New(3);
+    t2 = PyTuple_New(3);
+    if (t1 == NULL || t2 == NULL)
+        return NULL;
 
-	PyTuple_SET_ITEM(t1, 0, ((PySliceObject *)v)->start);
-	PyTuple_SET_ITEM(t1, 1, ((PySliceObject *)v)->stop);
-	PyTuple_SET_ITEM(t1, 2, ((PySliceObject *)v)->step);
-	PyTuple_SET_ITEM(t2, 0, ((PySliceObject *)w)->start);
-	PyTuple_SET_ITEM(t2, 1, ((PySliceObject *)w)->stop);
-	PyTuple_SET_ITEM(t2, 2, ((PySliceObject *)w)->step);
+    PyTuple_SET_ITEM(t1, 0, ((PySliceObject *)v)->start);
+    PyTuple_SET_ITEM(t1, 1, ((PySliceObject *)v)->stop);
+    PyTuple_SET_ITEM(t1, 2, ((PySliceObject *)v)->step);
+    PyTuple_SET_ITEM(t2, 0, ((PySliceObject *)w)->start);
+    PyTuple_SET_ITEM(t2, 1, ((PySliceObject *)w)->stop);
+    PyTuple_SET_ITEM(t2, 2, ((PySliceObject *)w)->step);
 
-	res = PyObject_RichCompare(t1, t2, op);
+    res = PyObject_RichCompare(t1, t2, op);
 
-	PyTuple_SET_ITEM(t1, 0, NULL);
-	PyTuple_SET_ITEM(t1, 1, NULL);
-	PyTuple_SET_ITEM(t1, 2, NULL);
-	PyTuple_SET_ITEM(t2, 0, NULL);
-	PyTuple_SET_ITEM(t2, 1, NULL);
-	PyTuple_SET_ITEM(t2, 2, NULL);
+    PyTuple_SET_ITEM(t1, 0, NULL);
+    PyTuple_SET_ITEM(t1, 1, NULL);
+    PyTuple_SET_ITEM(t1, 2, NULL);
+    PyTuple_SET_ITEM(t2, 0, NULL);
+    PyTuple_SET_ITEM(t2, 1, NULL);
+    PyTuple_SET_ITEM(t2, 2, NULL);
 
-	Py_DECREF(t1);
-	Py_DECREF(t2);
+    Py_DECREF(t1);
+    Py_DECREF(t2);
 
-	return res;
+    return res;
 }
 
 static long
 slice_hash(PySliceObject *v)
 {
-	PyErr_SetString(PyExc_TypeError, "unhashable type");
-	return -1L;
+    PyErr_SetString(PyExc_TypeError, "unhashable type");
+    return -1L;
 }
 
 PyTypeObject PySlice_Type = {
-	PyVarObject_HEAD_INIT(&PyType_Type, 0)
-	"slice",		/* Name of this type */
-	sizeof(PySliceObject),	/* Basic object size */
-	0,			/* Item size for varobject */
-	(destructor)slice_dealloc,		/* tp_dealloc */
-	0,					/* tp_print */
-	0,					/* tp_getattr */
-	0,					/* tp_setattr */
-	0,			 		/* tp_reserved */
-	(reprfunc)slice_repr,   		/* tp_repr */
-	0,					/* tp_as_number */
-	0,	    				/* tp_as_sequence */
-	0,					/* tp_as_mapping */
-	(hashfunc)slice_hash,			/* tp_hash */
-	0,					/* tp_call */
-	0,					/* tp_str */
-	PyObject_GenericGetAttr,		/* tp_getattro */
-	0,					/* tp_setattro */
-	0,					/* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT,			/* tp_flags */
-	slice_doc,				/* tp_doc */
-	0,					/* tp_traverse */
-	0,					/* tp_clear */
-	slice_richcompare,			/* tp_richcompare */
-	0,					/* tp_weaklistoffset */
-	0,					/* tp_iter */
-	0,					/* tp_iternext */
-	slice_methods,				/* tp_methods */
-	slice_members,				/* 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 */
-	slice_new,				/* tp_new */
+    PyVarObject_HEAD_INIT(&PyType_Type, 0)
+    "slice",                    /* Name of this type */
+    sizeof(PySliceObject),      /* Basic object size */
+    0,                          /* Item size for varobject */
+    (destructor)slice_dealloc,                  /* tp_dealloc */
+    0,                                          /* tp_print */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+    0,                                          /* tp_reserved */
+    (reprfunc)slice_repr,                       /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    (hashfunc)slice_hash,                       /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    PyObject_GenericGetAttr,                    /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                         /* tp_flags */
+    slice_doc,                                  /* tp_doc */
+    0,                                          /* tp_traverse */
+    0,                                          /* tp_clear */
+    slice_richcompare,                          /* tp_richcompare */
+    0,                                          /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    slice_methods,                              /* tp_methods */
+    slice_members,                              /* 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 */
+    slice_new,                                  /* tp_new */
 };