diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c
index ef6fb87..403f646 100644
--- a/Modules/arraymodule.c
+++ b/Modules/arraymodule.c
@@ -11,7 +11,7 @@
 #include <stddef.h>
 #else /* !STDC_HEADERS */
 #ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>		/* For size_t */
+#include <sys/types.h>          /* For size_t */
 #endif /* HAVE_SYS_TYPES_H */
 #endif /* !STDC_HEADERS */
 
@@ -22,18 +22,18 @@
  * functions aren't visible yet.
  */
 struct arraydescr {
-	int typecode;
-	int itemsize;
-	PyObject * (*getitem)(struct arrayobject *, Py_ssize_t);
-	int (*setitem)(struct arrayobject *, Py_ssize_t, PyObject *);
+    int typecode;
+    int itemsize;
+    PyObject * (*getitem)(struct arrayobject *, Py_ssize_t);
+    int (*setitem)(struct arrayobject *, Py_ssize_t, PyObject *);
 };
 
 typedef struct arrayobject {
-	PyObject_VAR_HEAD
-	char *ob_item;
-	Py_ssize_t allocated;
-	struct arraydescr *ob_descr;
-	PyObject *weakreflist; /* List of weak references */
+    PyObject_VAR_HEAD
+    char *ob_item;
+    Py_ssize_t allocated;
+    struct arraydescr *ob_descr;
+    PyObject *weakreflist; /* List of weak references */
 } arrayobject;
 
 static PyTypeObject Arraytype;
@@ -44,49 +44,49 @@
 static int
 array_resize(arrayobject *self, Py_ssize_t newsize)
 {
-	char *items;
-	size_t _new_size;
+    char *items;
+    size_t _new_size;
 
-	/* Bypass realloc() when a previous overallocation is large enough
-	   to accommodate the newsize.  If the newsize is 16 smaller than the
-	   current size, then proceed with the realloc() to shrink the list.
-	*/
+    /* Bypass realloc() when a previous overallocation is large enough
+       to accommodate the newsize.  If the newsize is 16 smaller than the
+       current size, then proceed with the realloc() to shrink the list.
+    */
 
-	if (self->allocated >= newsize &&
-	    Py_SIZE(self) < newsize + 16 &&
-	    self->ob_item != NULL) {
-		Py_SIZE(self) = newsize;
-		return 0;
-	}
+    if (self->allocated >= newsize &&
+        Py_SIZE(self) < newsize + 16 &&
+        self->ob_item != NULL) {
+        Py_SIZE(self) = newsize;
+        return 0;
+    }
 
-	/* This over-allocates proportional to the array size, making room
-	 * for additional growth.  The over-allocation is mild, but is
-	 * enough to give linear-time amortized behavior over a long
-	 * sequence of appends() in the presence of a poorly-performing
-	 * system realloc().
-	 * The growth pattern is:  0, 4, 8, 16, 25, 34, 46, 56, 67, 79, ...
-	 * Note, the pattern starts out the same as for lists but then
-	 * grows at a smaller rate so that larger arrays only overallocate
-	 * by about 1/16th -- this is done because arrays are presumed to be more
-	 * memory critical.
-	 */
+    /* This over-allocates proportional to the array size, making room
+     * for additional growth.  The over-allocation is mild, but is
+     * enough to give linear-time amortized behavior over a long
+     * sequence of appends() in the presence of a poorly-performing
+     * system realloc().
+     * The growth pattern is:  0, 4, 8, 16, 25, 34, 46, 56, 67, 79, ...
+     * Note, the pattern starts out the same as for lists but then
+     * grows at a smaller rate so that larger arrays only overallocate
+     * by about 1/16th -- this is done because arrays are presumed to be more
+     * memory critical.
+     */
 
-	_new_size = (newsize >> 4) + (Py_SIZE(self) < 8 ? 3 : 7) + newsize;
-	items = self->ob_item;
-	/* XXX The following multiplication and division does not optimize away 
-	   like it does for lists since the size is not known at compile time */
-	if (_new_size <= ((~(size_t)0) / self->ob_descr->itemsize))
-		PyMem_RESIZE(items, char, (_new_size * self->ob_descr->itemsize));
-	else
-		items = NULL;
-	if (items == NULL) {
-		PyErr_NoMemory();
-		return -1;
-	}
-	self->ob_item = items;
-	Py_SIZE(self) = newsize;
-	self->allocated = _new_size;
-	return 0;
+    _new_size = (newsize >> 4) + (Py_SIZE(self) < 8 ? 3 : 7) + newsize;
+    items = self->ob_item;
+    /* XXX The following multiplication and division does not optimize away
+       like it does for lists since the size is not known at compile time */
+    if (_new_size <= ((~(size_t)0) / self->ob_descr->itemsize))
+        PyMem_RESIZE(items, char, (_new_size * self->ob_descr->itemsize));
+    else
+        items = NULL;
+    if (items == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    self->ob_item = items;
+    Py_SIZE(self) = newsize;
+    self->allocated = _new_size;
+    return 0;
 }
 
 /****************************************************************************
@@ -104,308 +104,308 @@
 static PyObject *
 c_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1);
+    return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1);
 }
 
 static int
 c_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	char x;
-	if (!PyArg_Parse(v, "c;array item must be char", &x))
-		return -1;
-	if (i >= 0)
-		((char *)ap->ob_item)[i] = x;
-	return 0;
+    char x;
+    if (!PyArg_Parse(v, "c;array item must be char", &x))
+        return -1;
+    if (i >= 0)
+        ((char *)ap->ob_item)[i] = x;
+    return 0;
 }
 
 static PyObject *
 b_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	long x = ((char *)ap->ob_item)[i];
-	if (x >= 128)
-		x -= 256;
-	return PyInt_FromLong(x);
+    long x = ((char *)ap->ob_item)[i];
+    if (x >= 128)
+        x -= 256;
+    return PyInt_FromLong(x);
 }
 
 static int
 b_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	short x;
-	/* PyArg_Parse's 'b' formatter is for an unsigned char, therefore
-	   must use the next size up that is signed ('h') and manually do
-	   the overflow checking */
-	if (!PyArg_Parse(v, "h;array item must be integer", &x))
-		return -1;
-	else if (x < -128) {
-		PyErr_SetString(PyExc_OverflowError,
-			"signed char is less than minimum");
-		return -1;
-	}
-	else if (x > 127) {
-		PyErr_SetString(PyExc_OverflowError,
-			"signed char is greater than maximum");
-		return -1;
-	}
-	if (i >= 0)
-		((char *)ap->ob_item)[i] = (char)x;
-	return 0;
+    short x;
+    /* PyArg_Parse's 'b' formatter is for an unsigned char, therefore
+       must use the next size up that is signed ('h') and manually do
+       the overflow checking */
+    if (!PyArg_Parse(v, "h;array item must be integer", &x))
+        return -1;
+    else if (x < -128) {
+        PyErr_SetString(PyExc_OverflowError,
+            "signed char is less than minimum");
+        return -1;
+    }
+    else if (x > 127) {
+        PyErr_SetString(PyExc_OverflowError,
+            "signed char is greater than maximum");
+        return -1;
+    }
+    if (i >= 0)
+        ((char *)ap->ob_item)[i] = (char)x;
+    return 0;
 }
 
 static PyObject *
 BB_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	long x = ((unsigned char *)ap->ob_item)[i];
-	return PyInt_FromLong(x);
+    long x = ((unsigned char *)ap->ob_item)[i];
+    return PyInt_FromLong(x);
 }
 
 static int
 BB_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	unsigned char x;
-	/* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */
-	if (!PyArg_Parse(v, "b;array item must be integer", &x))
-		return -1;
-	if (i >= 0)
-		((char *)ap->ob_item)[i] = x;
-	return 0;
+    unsigned char x;
+    /* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */
+    if (!PyArg_Parse(v, "b;array item must be integer", &x))
+        return -1;
+    if (i >= 0)
+        ((char *)ap->ob_item)[i] = x;
+    return 0;
 }
 
 #ifdef Py_USING_UNICODE
 static PyObject *
 u_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	return PyUnicode_FromUnicode(&((Py_UNICODE *) ap->ob_item)[i], 1);
+    return PyUnicode_FromUnicode(&((Py_UNICODE *) ap->ob_item)[i], 1);
 }
 
 static int
 u_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	Py_UNICODE *p;
-	Py_ssize_t len;
+    Py_UNICODE *p;
+    Py_ssize_t len;
 
-	if (!PyArg_Parse(v, "u#;array item must be unicode character", &p, &len))
-		return -1;
-	if (len != 1) {
-		PyErr_SetString(PyExc_TypeError,
-				"array item must be unicode character");
-		return -1;
-	}
-	if (i >= 0)
-		((Py_UNICODE *)ap->ob_item)[i] = p[0];
-	return 0;
+    if (!PyArg_Parse(v, "u#;array item must be unicode character", &p, &len))
+        return -1;
+    if (len != 1) {
+        PyErr_SetString(PyExc_TypeError,
+                        "array item must be unicode character");
+        return -1;
+    }
+    if (i >= 0)
+        ((Py_UNICODE *)ap->ob_item)[i] = p[0];
+    return 0;
 }
 #endif
 
 static PyObject *
 h_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	return PyInt_FromLong((long) ((short *)ap->ob_item)[i]);
+    return PyInt_FromLong((long) ((short *)ap->ob_item)[i]);
 }
 
 static int
 h_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	short x;
-	/* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */
-	if (!PyArg_Parse(v, "h;array item must be integer", &x))
-		return -1;
-	if (i >= 0)
-		     ((short *)ap->ob_item)[i] = x;
-	return 0;
+    short x;
+    /* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */
+    if (!PyArg_Parse(v, "h;array item must be integer", &x))
+        return -1;
+    if (i >= 0)
+                 ((short *)ap->ob_item)[i] = x;
+    return 0;
 }
 
 static PyObject *
 HH_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	return PyInt_FromLong((long) ((unsigned short *)ap->ob_item)[i]);
+    return PyInt_FromLong((long) ((unsigned short *)ap->ob_item)[i]);
 }
 
 static int
 HH_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	int x;
-	/* PyArg_Parse's 'h' formatter is for a signed short, therefore
-	   must use the next size up and manually do the overflow checking */
-	if (!PyArg_Parse(v, "i;array item must be integer", &x))
-		return -1;
-	else if (x < 0) {
-		PyErr_SetString(PyExc_OverflowError,
-			"unsigned short is less than minimum");
-		return -1;
-	}
-	else if (x > USHRT_MAX) {
-		PyErr_SetString(PyExc_OverflowError,
-			"unsigned short is greater than maximum");
-		return -1;
-	}
-	if (i >= 0)
-		((short *)ap->ob_item)[i] = (short)x;
-	return 0;
+    int x;
+    /* PyArg_Parse's 'h' formatter is for a signed short, therefore
+       must use the next size up and manually do the overflow checking */
+    if (!PyArg_Parse(v, "i;array item must be integer", &x))
+        return -1;
+    else if (x < 0) {
+        PyErr_SetString(PyExc_OverflowError,
+            "unsigned short is less than minimum");
+        return -1;
+    }
+    else if (x > USHRT_MAX) {
+        PyErr_SetString(PyExc_OverflowError,
+            "unsigned short is greater than maximum");
+        return -1;
+    }
+    if (i >= 0)
+        ((short *)ap->ob_item)[i] = (short)x;
+    return 0;
 }
 
 static PyObject *
 i_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	return PyInt_FromLong((long) ((int *)ap->ob_item)[i]);
+    return PyInt_FromLong((long) ((int *)ap->ob_item)[i]);
 }
 
 static int
 i_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	int x;
-	/* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */
-	if (!PyArg_Parse(v, "i;array item must be integer", &x))
-		return -1;
-	if (i >= 0)
-		     ((int *)ap->ob_item)[i] = x;
-	return 0;
+    int x;
+    /* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */
+    if (!PyArg_Parse(v, "i;array item must be integer", &x))
+        return -1;
+    if (i >= 0)
+                 ((int *)ap->ob_item)[i] = x;
+    return 0;
 }
 
 static PyObject *
 II_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	return PyLong_FromUnsignedLong(
-		(unsigned long) ((unsigned int *)ap->ob_item)[i]);
+    return PyLong_FromUnsignedLong(
+        (unsigned long) ((unsigned int *)ap->ob_item)[i]);
 }
 
 static int
 II_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	unsigned long x;
-	if (PyLong_Check(v)) {
-		x = PyLong_AsUnsignedLong(v);
-		if (x == (unsigned long) -1 && PyErr_Occurred())
-			return -1;
-	}
-	else {
-		long y;
-		if (!PyArg_Parse(v, "l;array item must be integer", &y))
-			return -1;
-		if (y < 0) {
-			PyErr_SetString(PyExc_OverflowError,
-				"unsigned int is less than minimum");
-			return -1;
-		}
-		x = (unsigned long)y;
+    unsigned long x;
+    if (PyLong_Check(v)) {
+        x = PyLong_AsUnsignedLong(v);
+        if (x == (unsigned long) -1 && PyErr_Occurred())
+            return -1;
+    }
+    else {
+        long y;
+        if (!PyArg_Parse(v, "l;array item must be integer", &y))
+            return -1;
+        if (y < 0) {
+            PyErr_SetString(PyExc_OverflowError,
+                "unsigned int is less than minimum");
+            return -1;
+        }
+        x = (unsigned long)y;
 
-	}
-	if (x > UINT_MAX) {
-		PyErr_SetString(PyExc_OverflowError,
-			"unsigned int is greater than maximum");
-		return -1;
-	}
+    }
+    if (x > UINT_MAX) {
+        PyErr_SetString(PyExc_OverflowError,
+            "unsigned int is greater than maximum");
+        return -1;
+    }
 
-	if (i >= 0)
-		((unsigned int *)ap->ob_item)[i] = (unsigned int)x;
-	return 0;
+    if (i >= 0)
+        ((unsigned int *)ap->ob_item)[i] = (unsigned int)x;
+    return 0;
 }
 
 static PyObject *
 l_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	return PyInt_FromLong(((long *)ap->ob_item)[i]);
+    return PyInt_FromLong(((long *)ap->ob_item)[i]);
 }
 
 static int
 l_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	long x;
-	if (!PyArg_Parse(v, "l;array item must be integer", &x))
-		return -1;
-	if (i >= 0)
-		     ((long *)ap->ob_item)[i] = x;
-	return 0;
+    long x;
+    if (!PyArg_Parse(v, "l;array item must be integer", &x))
+        return -1;
+    if (i >= 0)
+                 ((long *)ap->ob_item)[i] = x;
+    return 0;
 }
 
 static PyObject *
 LL_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]);
+    return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]);
 }
 
 static int
 LL_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	unsigned long x;
-	if (PyLong_Check(v)) {
-		x = PyLong_AsUnsignedLong(v);
-		if (x == (unsigned long) -1 && PyErr_Occurred())
-			return -1;
-	}
-	else {
-		long y;
-		if (!PyArg_Parse(v, "l;array item must be integer", &y))
-			return -1;
-		if (y < 0) {
-			PyErr_SetString(PyExc_OverflowError,
-				"unsigned long is less than minimum");
-			return -1;
-		}
-		x = (unsigned long)y;
+    unsigned long x;
+    if (PyLong_Check(v)) {
+        x = PyLong_AsUnsignedLong(v);
+        if (x == (unsigned long) -1 && PyErr_Occurred())
+            return -1;
+    }
+    else {
+        long y;
+        if (!PyArg_Parse(v, "l;array item must be integer", &y))
+            return -1;
+        if (y < 0) {
+            PyErr_SetString(PyExc_OverflowError,
+                "unsigned long is less than minimum");
+            return -1;
+        }
+        x = (unsigned long)y;
 
-	}
-	if (x > ULONG_MAX) {
-		PyErr_SetString(PyExc_OverflowError,
-			"unsigned long is greater than maximum");
-		return -1;
-	}
+    }
+    if (x > ULONG_MAX) {
+        PyErr_SetString(PyExc_OverflowError,
+            "unsigned long is greater than maximum");
+        return -1;
+    }
 
-	if (i >= 0)
-		((unsigned long *)ap->ob_item)[i] = x;
-	return 0;
+    if (i >= 0)
+        ((unsigned long *)ap->ob_item)[i] = x;
+    return 0;
 }
 
 static PyObject *
 f_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]);
+    return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]);
 }
 
 static int
 f_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	float x;
-	if (!PyArg_Parse(v, "f;array item must be float", &x))
-		return -1;
-	if (i >= 0)
-		     ((float *)ap->ob_item)[i] = x;
-	return 0;
+    float x;
+    if (!PyArg_Parse(v, "f;array item must be float", &x))
+        return -1;
+    if (i >= 0)
+                 ((float *)ap->ob_item)[i] = x;
+    return 0;
 }
 
 static PyObject *
 d_getitem(arrayobject *ap, Py_ssize_t i)
 {
-	return PyFloat_FromDouble(((double *)ap->ob_item)[i]);
+    return PyFloat_FromDouble(((double *)ap->ob_item)[i]);
 }
 
 static int
 d_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
 {
-	double x;
-	if (!PyArg_Parse(v, "d;array item must be float", &x))
-		return -1;
-	if (i >= 0)
-		     ((double *)ap->ob_item)[i] = x;
-	return 0;
+    double x;
+    if (!PyArg_Parse(v, "d;array item must be float", &x))
+        return -1;
+    if (i >= 0)
+                 ((double *)ap->ob_item)[i] = x;
+    return 0;
 }
 
 /* Description of types */
 static struct arraydescr descriptors[] = {
-	{'c', sizeof(char), c_getitem, c_setitem},
-	{'b', sizeof(char), b_getitem, b_setitem},
-	{'B', sizeof(char), BB_getitem, BB_setitem},
+    {'c', sizeof(char), c_getitem, c_setitem},
+    {'b', sizeof(char), b_getitem, b_setitem},
+    {'B', sizeof(char), BB_getitem, BB_setitem},
 #ifdef Py_USING_UNICODE
-	{'u', sizeof(Py_UNICODE), u_getitem, u_setitem},
+    {'u', sizeof(Py_UNICODE), u_getitem, u_setitem},
 #endif
-	{'h', sizeof(short), h_getitem, h_setitem},
-	{'H', sizeof(short), HH_getitem, HH_setitem},
-	{'i', sizeof(int), i_getitem, i_setitem},
-	{'I', sizeof(int), II_getitem, II_setitem},
-	{'l', sizeof(long), l_getitem, l_setitem},
-	{'L', sizeof(long), LL_getitem, LL_setitem},
-	{'f', sizeof(float), f_getitem, f_setitem},
-	{'d', sizeof(double), d_getitem, d_setitem},
-	{'\0', 0, 0, 0} /* Sentinel */
+    {'h', sizeof(short), h_getitem, h_setitem},
+    {'H', sizeof(short), HH_getitem, HH_setitem},
+    {'i', sizeof(int), i_getitem, i_setitem},
+    {'I', sizeof(int), II_getitem, II_setitem},
+    {'l', sizeof(long), l_getitem, l_setitem},
+    {'L', sizeof(long), LL_getitem, LL_setitem},
+    {'f', sizeof(float), f_getitem, f_setitem},
+    {'d', sizeof(double), d_getitem, d_setitem},
+    {'\0', 0, 0, 0} /* Sentinel */
 };
 
 /****************************************************************************
@@ -415,78 +415,78 @@
 static PyObject *
 newarrayobject(PyTypeObject *type, Py_ssize_t size, struct arraydescr *descr)
 {
-	arrayobject *op;
-	size_t nbytes;
+    arrayobject *op;
+    size_t nbytes;
 
-	if (size < 0) {
-		PyErr_BadInternalCall();
-		return NULL;
-	}
+    if (size < 0) {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
 
-	nbytes = size * descr->itemsize;
-	/* Check for overflow */
-	if (nbytes / descr->itemsize != (size_t)size) {
-		return PyErr_NoMemory();
-	}
-	op = (arrayobject *) type->tp_alloc(type, 0);
-	if (op == NULL) {
-		return NULL;
-	}
-	op->ob_descr = descr;
-	op->allocated = size;
-	op->weakreflist = NULL;
-	Py_SIZE(op) = size;
-	if (size <= 0) {
-		op->ob_item = NULL;
-	}
-	else {
-		op->ob_item = PyMem_NEW(char, nbytes);
-		if (op->ob_item == NULL) {
-			Py_DECREF(op);
-			return PyErr_NoMemory();
-		}
-	}
-	return (PyObject *) op;
+    nbytes = size * descr->itemsize;
+    /* Check for overflow */
+    if (nbytes / descr->itemsize != (size_t)size) {
+        return PyErr_NoMemory();
+    }
+    op = (arrayobject *) type->tp_alloc(type, 0);
+    if (op == NULL) {
+        return NULL;
+    }
+    op->ob_descr = descr;
+    op->allocated = size;
+    op->weakreflist = NULL;
+    Py_SIZE(op) = size;
+    if (size <= 0) {
+        op->ob_item = NULL;
+    }
+    else {
+        op->ob_item = PyMem_NEW(char, nbytes);
+        if (op->ob_item == NULL) {
+            Py_DECREF(op);
+            return PyErr_NoMemory();
+        }
+    }
+    return (PyObject *) op;
 }
 
 static PyObject *
 getarrayitem(PyObject *op, Py_ssize_t i)
 {
-	register arrayobject *ap;
-	assert(array_Check(op));
-	ap = (arrayobject *)op;
-	assert(i>=0 && i<Py_SIZE(ap));
-	return (*ap->ob_descr->getitem)(ap, i);
+    register arrayobject *ap;
+    assert(array_Check(op));
+    ap = (arrayobject *)op;
+    assert(i>=0 && i<Py_SIZE(ap));
+    return (*ap->ob_descr->getitem)(ap, i);
 }
 
 static int
 ins1(arrayobject *self, Py_ssize_t where, PyObject *v)
 {
-	char *items;
-	Py_ssize_t n = Py_SIZE(self);
-	if (v == NULL) {
-		PyErr_BadInternalCall();
-		return -1;
-	}
-	if ((*self->ob_descr->setitem)(self, -1, v) < 0)
-		return -1;
+    char *items;
+    Py_ssize_t n = Py_SIZE(self);
+    if (v == NULL) {
+        PyErr_BadInternalCall();
+        return -1;
+    }
+    if ((*self->ob_descr->setitem)(self, -1, v) < 0)
+        return -1;
 
-	if (array_resize(self, n+1) == -1)
-		return -1;
-	items = self->ob_item;
-	if (where < 0) {
-		where += n;
-		if (where < 0)
-			where = 0;
-	}
-	if (where > n)
-		where = n;
-	/* appends don't need to call memmove() */
-	if (where != n)
-		memmove(items + (where+1)*self->ob_descr->itemsize,
-			items + where*self->ob_descr->itemsize,
-			(n-where)*self->ob_descr->itemsize);
-	return (*self->ob_descr->setitem)(self, where, v);
+    if (array_resize(self, n+1) == -1)
+        return -1;
+    items = self->ob_item;
+    if (where < 0) {
+        where += n;
+        if (where < 0)
+            where = 0;
+    }
+    if (where > n)
+        where = n;
+    /* appends don't need to call memmove() */
+    if (where != n)
+        memmove(items + (where+1)*self->ob_descr->itemsize,
+            items + where*self->ob_descr->itemsize,
+            (n-where)*self->ob_descr->itemsize);
+    return (*self->ob_descr->setitem)(self, where, v);
 }
 
 /* Methods */
@@ -494,141 +494,141 @@
 static void
 array_dealloc(arrayobject *op)
 {
-	if (op->weakreflist != NULL)
-		PyObject_ClearWeakRefs((PyObject *) op);
-	if (op->ob_item != NULL)
-		PyMem_DEL(op->ob_item);
-	Py_TYPE(op)->tp_free((PyObject *)op);
+    if (op->weakreflist != NULL)
+        PyObject_ClearWeakRefs((PyObject *) op);
+    if (op->ob_item != NULL)
+        PyMem_DEL(op->ob_item);
+    Py_TYPE(op)->tp_free((PyObject *)op);
 }
 
 static PyObject *
 array_richcompare(PyObject *v, PyObject *w, int op)
 {
-	arrayobject *va, *wa;
-	PyObject *vi = NULL;
-	PyObject *wi = NULL;
-	Py_ssize_t i, k;
-	PyObject *res;
+    arrayobject *va, *wa;
+    PyObject *vi = NULL;
+    PyObject *wi = NULL;
+    Py_ssize_t i, k;
+    PyObject *res;
 
-	if (!array_Check(v) || !array_Check(w)) {
-		Py_INCREF(Py_NotImplemented);
-		return Py_NotImplemented;
-	}
+    if (!array_Check(v) || !array_Check(w)) {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
 
-	va = (arrayobject *)v;
-	wa = (arrayobject *)w;
+    va = (arrayobject *)v;
+    wa = (arrayobject *)w;
 
-	if (Py_SIZE(va) != Py_SIZE(wa) && (op == Py_EQ || op == Py_NE)) {
-		/* Shortcut: if the lengths differ, the arrays differ */
-		if (op == Py_EQ)
-			res = Py_False;
-		else
-			res = Py_True;
-		Py_INCREF(res);
-		return res;
-	}
+    if (Py_SIZE(va) != Py_SIZE(wa) && (op == Py_EQ || op == Py_NE)) {
+        /* Shortcut: if the lengths differ, the arrays differ */
+        if (op == Py_EQ)
+            res = Py_False;
+        else
+            res = Py_True;
+        Py_INCREF(res);
+        return res;
+    }
 
-	/* Search for the first index where items are different */
-	k = 1;
-	for (i = 0; i < Py_SIZE(va) && i < Py_SIZE(wa); i++) {
-		vi = getarrayitem(v, i);
-		wi = getarrayitem(w, i);
-		if (vi == NULL || wi == NULL) {
-			Py_XDECREF(vi);
-			Py_XDECREF(wi);
-			return NULL;
-		}
-		k = PyObject_RichCompareBool(vi, wi, Py_EQ);
-		if (k == 0)
-			break; /* Keeping vi and wi alive! */
-		Py_DECREF(vi);
-		Py_DECREF(wi);
-		if (k < 0)
-			return NULL;
-	}
+    /* Search for the first index where items are different */
+    k = 1;
+    for (i = 0; i < Py_SIZE(va) && i < Py_SIZE(wa); i++) {
+        vi = getarrayitem(v, i);
+        wi = getarrayitem(w, i);
+        if (vi == NULL || wi == NULL) {
+            Py_XDECREF(vi);
+            Py_XDECREF(wi);
+            return NULL;
+        }
+        k = PyObject_RichCompareBool(vi, wi, Py_EQ);
+        if (k == 0)
+            break; /* Keeping vi and wi alive! */
+        Py_DECREF(vi);
+        Py_DECREF(wi);
+        if (k < 0)
+            return NULL;
+    }
 
-	if (k) {
-		/* No more items to compare -- compare sizes */
-		Py_ssize_t vs = Py_SIZE(va);
-		Py_ssize_t ws = Py_SIZE(wa);
-		int cmp;
-		switch (op) {
-		case Py_LT: cmp = vs <  ws; break;
-		case Py_LE: cmp = vs <= ws; break;
-		case Py_EQ: cmp = vs == ws; break;
-		case Py_NE: cmp = vs != ws; break;
-		case Py_GT: cmp = vs >  ws; break;
-		case Py_GE: cmp = vs >= ws; break;
-		default: return NULL; /* cannot happen */
-		}
-		if (cmp)
-			res = Py_True;
-		else
-			res = Py_False;
-		Py_INCREF(res);
-		return res;
-	}
+    if (k) {
+        /* No more items to compare -- compare sizes */
+        Py_ssize_t vs = Py_SIZE(va);
+        Py_ssize_t ws = Py_SIZE(wa);
+        int cmp;
+        switch (op) {
+        case Py_LT: cmp = vs <  ws; break;
+        case Py_LE: cmp = vs <= ws; break;
+        case Py_EQ: cmp = vs == ws; break;
+        case Py_NE: cmp = vs != ws; break;
+        case Py_GT: cmp = vs >  ws; break;
+        case Py_GE: cmp = vs >= ws; break;
+        default: return NULL; /* cannot happen */
+        }
+        if (cmp)
+            res = Py_True;
+        else
+            res = Py_False;
+        Py_INCREF(res);
+        return res;
+    }
 
-	/* We have an item that differs.  First, shortcuts for EQ/NE */
-	if (op == Py_EQ) {
-		Py_INCREF(Py_False);
-		res = Py_False;
-	}
-	else if (op == Py_NE) {
-		Py_INCREF(Py_True);
-		res = Py_True;
-	}
-	else {
-		/* Compare the final item again using the proper operator */
-		res = PyObject_RichCompare(vi, wi, op);
-	}
-	Py_DECREF(vi);
-	Py_DECREF(wi);
-	return res;
+    /* We have an item that differs.  First, shortcuts for EQ/NE */
+    if (op == Py_EQ) {
+        Py_INCREF(Py_False);
+        res = Py_False;
+    }
+    else if (op == Py_NE) {
+        Py_INCREF(Py_True);
+        res = Py_True;
+    }
+    else {
+        /* Compare the final item again using the proper operator */
+        res = PyObject_RichCompare(vi, wi, op);
+    }
+    Py_DECREF(vi);
+    Py_DECREF(wi);
+    return res;
 }
 
 static Py_ssize_t
 array_length(arrayobject *a)
 {
-	return Py_SIZE(a);
+    return Py_SIZE(a);
 }
 
 static PyObject *
 array_item(arrayobject *a, Py_ssize_t i)
 {
-	if (i < 0 || i >= Py_SIZE(a)) {
-		PyErr_SetString(PyExc_IndexError, "array index out of range");
-		return NULL;
-	}
-	return getarrayitem((PyObject *)a, i);
+    if (i < 0 || i >= Py_SIZE(a)) {
+        PyErr_SetString(PyExc_IndexError, "array index out of range");
+        return NULL;
+    }
+    return getarrayitem((PyObject *)a, i);
 }
 
 static PyObject *
 array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
 {
-	arrayobject *np;
-	if (ilow < 0)
-		ilow = 0;
-	else if (ilow > Py_SIZE(a))
-		ilow = Py_SIZE(a);
-	if (ihigh < 0)
-		ihigh = 0;
-	if (ihigh < ilow)
-		ihigh = ilow;
-	else if (ihigh > Py_SIZE(a))
-		ihigh = Py_SIZE(a);
-	np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr);
-	if (np == NULL)
-		return NULL;
-	memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize,
-	       (ihigh-ilow) * a->ob_descr->itemsize);
-	return (PyObject *)np;
+    arrayobject *np;
+    if (ilow < 0)
+        ilow = 0;
+    else if (ilow > Py_SIZE(a))
+        ilow = Py_SIZE(a);
+    if (ihigh < 0)
+        ihigh = 0;
+    if (ihigh < ilow)
+        ihigh = ilow;
+    else if (ihigh > Py_SIZE(a))
+        ihigh = Py_SIZE(a);
+    np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr);
+    if (np == NULL)
+        return NULL;
+    memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize,
+           (ihigh-ilow) * a->ob_descr->itemsize);
+    return (PyObject *)np;
 }
 
 static PyObject *
 array_copy(arrayobject *a, PyObject *unused)
 {
-	return array_slice(a, 0, Py_SIZE(a));
+    return array_slice(a, 0, Py_SIZE(a));
 }
 
 PyDoc_STRVAR(copy_doc,
@@ -639,297 +639,297 @@
 static PyObject *
 array_concat(arrayobject *a, PyObject *bb)
 {
-	Py_ssize_t size;
-	arrayobject *np;
-	if (!array_Check(bb)) {
-		PyErr_Format(PyExc_TypeError,
-		     "can only append array (not \"%.200s\") to array",
-			     Py_TYPE(bb)->tp_name);
-		return NULL;
-	}
+    Py_ssize_t size;
+    arrayobject *np;
+    if (!array_Check(bb)) {
+        PyErr_Format(PyExc_TypeError,
+             "can only append array (not \"%.200s\") to array",
+                 Py_TYPE(bb)->tp_name);
+        return NULL;
+    }
 #define b ((arrayobject *)bb)
-	if (a->ob_descr != b->ob_descr) {
-		PyErr_BadArgument();
-		return NULL;
-	}
-	if (Py_SIZE(a) > PY_SSIZE_T_MAX - Py_SIZE(b)) {
-		return PyErr_NoMemory();
-	}
-	size = Py_SIZE(a) + Py_SIZE(b);
-	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
-	if (np == NULL) {
-		return NULL;
-	}
-	memcpy(np->ob_item, a->ob_item, Py_SIZE(a)*a->ob_descr->itemsize);
-	memcpy(np->ob_item + Py_SIZE(a)*a->ob_descr->itemsize,
-	       b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
-	return (PyObject *)np;
+    if (a->ob_descr != b->ob_descr) {
+        PyErr_BadArgument();
+        return NULL;
+    }
+    if (Py_SIZE(a) > PY_SSIZE_T_MAX - Py_SIZE(b)) {
+        return PyErr_NoMemory();
+    }
+    size = Py_SIZE(a) + Py_SIZE(b);
+    np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
+    if (np == NULL) {
+        return NULL;
+    }
+    memcpy(np->ob_item, a->ob_item, Py_SIZE(a)*a->ob_descr->itemsize);
+    memcpy(np->ob_item + Py_SIZE(a)*a->ob_descr->itemsize,
+           b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
+    return (PyObject *)np;
 #undef b
 }
 
 static PyObject *
 array_repeat(arrayobject *a, Py_ssize_t n)
 {
-	Py_ssize_t i;
-	Py_ssize_t size;
-	arrayobject *np;
-	char *p;
-	Py_ssize_t nbytes;
-	if (n < 0)
-		n = 0;
-	if ((Py_SIZE(a) != 0) && (n > PY_SSIZE_T_MAX / Py_SIZE(a))) {
-		return PyErr_NoMemory();
-	}
-	size = Py_SIZE(a) * n;
-	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
-	if (np == NULL)
-		return NULL;
-	p = np->ob_item;
-	nbytes = Py_SIZE(a) * a->ob_descr->itemsize;
-	for (i = 0; i < n; i++) {
-		memcpy(p, a->ob_item, nbytes);
-		p += nbytes;
-	}
-	return (PyObject *) np;
+    Py_ssize_t i;
+    Py_ssize_t size;
+    arrayobject *np;
+    char *p;
+    Py_ssize_t nbytes;
+    if (n < 0)
+        n = 0;
+    if ((Py_SIZE(a) != 0) && (n > PY_SSIZE_T_MAX / Py_SIZE(a))) {
+        return PyErr_NoMemory();
+    }
+    size = Py_SIZE(a) * n;
+    np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
+    if (np == NULL)
+        return NULL;
+    p = np->ob_item;
+    nbytes = Py_SIZE(a) * a->ob_descr->itemsize;
+    for (i = 0; i < n; i++) {
+        memcpy(p, a->ob_item, nbytes);
+        p += nbytes;
+    }
+    return (PyObject *) np;
 }
 
 static int
 array_ass_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
 {
-	char *item;
-	Py_ssize_t n; /* Size of replacement array */
-	Py_ssize_t d; /* Change in size */
+    char *item;
+    Py_ssize_t n; /* Size of replacement array */
+    Py_ssize_t d; /* Change in size */
 #define b ((arrayobject *)v)
-	if (v == NULL)
-		n = 0;
-	else if (array_Check(v)) {
-		n = Py_SIZE(b);
-		if (a == b) {
-			/* Special case "a[i:j] = a" -- copy b first */
-			int ret;
-			v = array_slice(b, 0, n);
-			if (!v)
-				return -1;
-			ret = array_ass_slice(a, ilow, ihigh, v);
-			Py_DECREF(v);
-			return ret;
-		}
-		if (b->ob_descr != a->ob_descr) {
-			PyErr_BadArgument();
-			return -1;
-		}
-	}
-	else {
-		PyErr_Format(PyExc_TypeError,
-	     "can only assign array (not \"%.200s\") to array slice",
-			     Py_TYPE(v)->tp_name);
-		return -1;
-	}
-	if (ilow < 0)
-		ilow = 0;
-	else if (ilow > Py_SIZE(a))
-		ilow = Py_SIZE(a);
-	if (ihigh < 0)
-		ihigh = 0;
-	if (ihigh < ilow)
-		ihigh = ilow;
-	else if (ihigh > Py_SIZE(a))
-		ihigh = Py_SIZE(a);
-	item = a->ob_item;
-	d = n - (ihigh-ilow);
-	if (d < 0) { /* Delete -d items */
-		memmove(item + (ihigh+d)*a->ob_descr->itemsize,
-			item + ihigh*a->ob_descr->itemsize,
-			(Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
-		Py_SIZE(a) += d;
-		PyMem_RESIZE(item, char, Py_SIZE(a)*a->ob_descr->itemsize);
-						/* Can't fail */
-		a->ob_item = item;
-		a->allocated = Py_SIZE(a);
-	}
-	else if (d > 0) { /* Insert d items */
-		PyMem_RESIZE(item, char,
-			     (Py_SIZE(a) + d)*a->ob_descr->itemsize);
-		if (item == NULL) {
-			PyErr_NoMemory();
-			return -1;
-		}
-		memmove(item + (ihigh+d)*a->ob_descr->itemsize,
-			item + ihigh*a->ob_descr->itemsize,
-			(Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
-		a->ob_item = item;
-		Py_SIZE(a) += d;
-		a->allocated = Py_SIZE(a);
-	}
-	if (n > 0)
-		memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,
-		       n*b->ob_descr->itemsize);
-	return 0;
+    if (v == NULL)
+        n = 0;
+    else if (array_Check(v)) {
+        n = Py_SIZE(b);
+        if (a == b) {
+            /* Special case "a[i:j] = a" -- copy b first */
+            int ret;
+            v = array_slice(b, 0, n);
+            if (!v)
+                return -1;
+            ret = array_ass_slice(a, ilow, ihigh, v);
+            Py_DECREF(v);
+            return ret;
+        }
+        if (b->ob_descr != a->ob_descr) {
+            PyErr_BadArgument();
+            return -1;
+        }
+    }
+    else {
+        PyErr_Format(PyExc_TypeError,
+         "can only assign array (not \"%.200s\") to array slice",
+                         Py_TYPE(v)->tp_name);
+        return -1;
+    }
+    if (ilow < 0)
+        ilow = 0;
+    else if (ilow > Py_SIZE(a))
+        ilow = Py_SIZE(a);
+    if (ihigh < 0)
+        ihigh = 0;
+    if (ihigh < ilow)
+        ihigh = ilow;
+    else if (ihigh > Py_SIZE(a))
+        ihigh = Py_SIZE(a);
+    item = a->ob_item;
+    d = n - (ihigh-ilow);
+    if (d < 0) { /* Delete -d items */
+        memmove(item + (ihigh+d)*a->ob_descr->itemsize,
+            item + ihigh*a->ob_descr->itemsize,
+            (Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
+        Py_SIZE(a) += d;
+        PyMem_RESIZE(item, char, Py_SIZE(a)*a->ob_descr->itemsize);
+                                        /* Can't fail */
+        a->ob_item = item;
+        a->allocated = Py_SIZE(a);
+    }
+    else if (d > 0) { /* Insert d items */
+        PyMem_RESIZE(item, char,
+                     (Py_SIZE(a) + d)*a->ob_descr->itemsize);
+        if (item == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        memmove(item + (ihigh+d)*a->ob_descr->itemsize,
+            item + ihigh*a->ob_descr->itemsize,
+            (Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
+        a->ob_item = item;
+        Py_SIZE(a) += d;
+        a->allocated = Py_SIZE(a);
+    }
+    if (n > 0)
+        memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,
+               n*b->ob_descr->itemsize);
+    return 0;
 #undef b
 }
 
 static int
 array_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v)
 {
-	if (i < 0 || i >= Py_SIZE(a)) {
-		PyErr_SetString(PyExc_IndexError,
-			         "array assignment index out of range");
-		return -1;
-	}
-	if (v == NULL)
-		return array_ass_slice(a, i, i+1, v);
-	return (*a->ob_descr->setitem)(a, i, v);
+    if (i < 0 || i >= Py_SIZE(a)) {
+        PyErr_SetString(PyExc_IndexError,
+                         "array assignment index out of range");
+        return -1;
+    }
+    if (v == NULL)
+        return array_ass_slice(a, i, i+1, v);
+    return (*a->ob_descr->setitem)(a, i, v);
 }
 
 static int
 setarrayitem(PyObject *a, Py_ssize_t i, PyObject *v)
 {
-	assert(array_Check(a));
-	return array_ass_item((arrayobject *)a, i, v);
+    assert(array_Check(a));
+    return array_ass_item((arrayobject *)a, i, v);
 }
 
 static int
 array_iter_extend(arrayobject *self, PyObject *bb)
 {
-	PyObject *it, *v;
+    PyObject *it, *v;
 
-	it = PyObject_GetIter(bb);
-	if (it == NULL)
-		return -1;
+    it = PyObject_GetIter(bb);
+    if (it == NULL)
+        return -1;
 
-	while ((v = PyIter_Next(it)) != NULL) {
-		if (ins1(self, (int) Py_SIZE(self), v) != 0) {
-			Py_DECREF(v);
-			Py_DECREF(it);
-			return -1;
-		}
-		Py_DECREF(v);
-	}
-	Py_DECREF(it);
-	if (PyErr_Occurred())
-		return -1;
-	return 0;
+    while ((v = PyIter_Next(it)) != NULL) {
+        if (ins1(self, (int) Py_SIZE(self), v) != 0) {
+            Py_DECREF(v);
+            Py_DECREF(it);
+            return -1;
+        }
+        Py_DECREF(v);
+    }
+    Py_DECREF(it);
+    if (PyErr_Occurred())
+        return -1;
+    return 0;
 }
 
 static int
 array_do_extend(arrayobject *self, PyObject *bb)
 {
-	Py_ssize_t size;
-	char *old_item;
+    Py_ssize_t size;
+    char *old_item;
 
-	if (!array_Check(bb))
-		return array_iter_extend(self, bb);
+    if (!array_Check(bb))
+        return array_iter_extend(self, bb);
 #define b ((arrayobject *)bb)
-	if (self->ob_descr != b->ob_descr) {
-		PyErr_SetString(PyExc_TypeError,
-			     "can only extend with array of same kind");
-		return -1;
-	}
-	if ((Py_SIZE(self) > PY_SSIZE_T_MAX - Py_SIZE(b)) ||
-		((Py_SIZE(self) + Py_SIZE(b)) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
-		PyErr_NoMemory();
-		return -1;
-	}
-	size = Py_SIZE(self) + Py_SIZE(b);
-	old_item = self->ob_item;
-        PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);
-        if (self->ob_item == NULL) {
-		self->ob_item = old_item;
-		PyErr_NoMemory();
-		return -1;
-        }
-	memcpy(self->ob_item + Py_SIZE(self)*self->ob_descr->itemsize,
-               b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
-	Py_SIZE(self) = size;
-	self->allocated = size;
+    if (self->ob_descr != b->ob_descr) {
+        PyErr_SetString(PyExc_TypeError,
+                     "can only extend with array of same kind");
+        return -1;
+    }
+    if ((Py_SIZE(self) > PY_SSIZE_T_MAX - Py_SIZE(b)) ||
+        ((Py_SIZE(self) + Py_SIZE(b)) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    size = Py_SIZE(self) + Py_SIZE(b);
+    old_item = self->ob_item;
+    PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);
+    if (self->ob_item == NULL) {
+        self->ob_item = old_item;
+        PyErr_NoMemory();
+        return -1;
+    }
+    memcpy(self->ob_item + Py_SIZE(self)*self->ob_descr->itemsize,
+           b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
+    Py_SIZE(self) = size;
+    self->allocated = size;
 
-	return 0;
+    return 0;
 #undef b
 }
 
 static PyObject *
 array_inplace_concat(arrayobject *self, PyObject *bb)
 {
-	if (!array_Check(bb)) {
-		PyErr_Format(PyExc_TypeError,
-			"can only extend array with array (not \"%.200s\")",
-			Py_TYPE(bb)->tp_name);
-		return NULL;
-	}
-	if (array_do_extend(self, bb) == -1)
-		return NULL;
-	Py_INCREF(self);
-	return (PyObject *)self;
+    if (!array_Check(bb)) {
+        PyErr_Format(PyExc_TypeError,
+            "can only extend array with array (not \"%.200s\")",
+            Py_TYPE(bb)->tp_name);
+        return NULL;
+    }
+    if (array_do_extend(self, bb) == -1)
+        return NULL;
+    Py_INCREF(self);
+    return (PyObject *)self;
 }
 
 static PyObject *
 array_inplace_repeat(arrayobject *self, Py_ssize_t n)
 {
-	char *items, *p;
-	Py_ssize_t size, i;
+    char *items, *p;
+    Py_ssize_t size, i;
 
-	if (Py_SIZE(self) > 0) {
-		if (n < 0)
-			n = 0;
-		items = self->ob_item;
-		if ((self->ob_descr->itemsize != 0) && 
-			(Py_SIZE(self) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
-			return PyErr_NoMemory();
-		}
-		size = Py_SIZE(self) * self->ob_descr->itemsize;
-		if (n == 0) {
-			PyMem_FREE(items);
-			self->ob_item = NULL;
-			Py_SIZE(self) = 0;
-			self->allocated = 0;
-		}
-		else {
-			if (size > PY_SSIZE_T_MAX / n) {
-				return PyErr_NoMemory();
-			}
-			PyMem_RESIZE(items, char, n * size);
-			if (items == NULL)
-				return PyErr_NoMemory();
-			p = items;
-			for (i = 1; i < n; i++) {
-				p += size;
-				memcpy(p, items, size);
-			}
-			self->ob_item = items;
-			Py_SIZE(self) *= n;
-			self->allocated = Py_SIZE(self);
-		}
-	}
-	Py_INCREF(self);
-	return (PyObject *)self;
+    if (Py_SIZE(self) > 0) {
+        if (n < 0)
+            n = 0;
+        items = self->ob_item;
+        if ((self->ob_descr->itemsize != 0) &&
+            (Py_SIZE(self) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
+            return PyErr_NoMemory();
+        }
+        size = Py_SIZE(self) * self->ob_descr->itemsize;
+        if (n == 0) {
+            PyMem_FREE(items);
+            self->ob_item = NULL;
+            Py_SIZE(self) = 0;
+            self->allocated = 0;
+        }
+        else {
+            if (size > PY_SSIZE_T_MAX / n) {
+                return PyErr_NoMemory();
+            }
+            PyMem_RESIZE(items, char, n * size);
+            if (items == NULL)
+                return PyErr_NoMemory();
+            p = items;
+            for (i = 1; i < n; i++) {
+                p += size;
+                memcpy(p, items, size);
+            }
+            self->ob_item = items;
+            Py_SIZE(self) *= n;
+            self->allocated = Py_SIZE(self);
+        }
+    }
+    Py_INCREF(self);
+    return (PyObject *)self;
 }
 
 
 static PyObject *
 ins(arrayobject *self, Py_ssize_t where, PyObject *v)
 {
-	if (ins1(self, where, v) != 0)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (ins1(self, where, v) != 0)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 array_count(arrayobject *self, PyObject *v)
 {
-	Py_ssize_t count = 0;
-	Py_ssize_t i;
+    Py_ssize_t count = 0;
+    Py_ssize_t i;
 
-	for (i = 0; i < Py_SIZE(self); i++) {
-		PyObject *selfi = getarrayitem((PyObject *)self, i);
-		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
-		Py_DECREF(selfi);
-		if (cmp > 0)
-			count++;
-		else if (cmp < 0)
-			return NULL;
-	}
-	return PyInt_FromSsize_t(count);
+    for (i = 0; i < Py_SIZE(self); i++) {
+        PyObject *selfi = getarrayitem((PyObject *)self, i);
+        int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
+        Py_DECREF(selfi);
+        if (cmp > 0)
+            count++;
+        else if (cmp < 0)
+            return NULL;
+    }
+    return PyInt_FromSsize_t(count);
 }
 
 PyDoc_STRVAR(count_doc,
@@ -940,20 +940,20 @@
 static PyObject *
 array_index(arrayobject *self, PyObject *v)
 {
-	Py_ssize_t i;
+    Py_ssize_t i;
 
-	for (i = 0; i < Py_SIZE(self); i++) {
-		PyObject *selfi = getarrayitem((PyObject *)self, i);
-		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
-		Py_DECREF(selfi);
-		if (cmp > 0) {
-			return PyInt_FromLong((long)i);
-		}
-		else if (cmp < 0)
-			return NULL;
-	}
-	PyErr_SetString(PyExc_ValueError, "array.index(x): x not in list");
-	return NULL;
+    for (i = 0; i < Py_SIZE(self); i++) {
+        PyObject *selfi = getarrayitem((PyObject *)self, i);
+        int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
+        Py_DECREF(selfi);
+        if (cmp > 0) {
+            return PyInt_FromLong((long)i);
+        }
+        else if (cmp < 0)
+            return NULL;
+    }
+    PyErr_SetString(PyExc_ValueError, "array.index(x): x not in list");
+    return NULL;
 }
 
 PyDoc_STRVAR(index_doc,
@@ -964,38 +964,38 @@
 static int
 array_contains(arrayobject *self, PyObject *v)
 {
-	Py_ssize_t i;
-	int cmp;
+    Py_ssize_t i;
+    int cmp;
 
-	for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(self); i++) {
-		PyObject *selfi = getarrayitem((PyObject *)self, i);
-		cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
-		Py_DECREF(selfi);
-	}
-	return cmp;
+    for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(self); i++) {
+        PyObject *selfi = getarrayitem((PyObject *)self, i);
+        cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
+        Py_DECREF(selfi);
+    }
+    return cmp;
 }
 
 static PyObject *
 array_remove(arrayobject *self, PyObject *v)
 {
-	int i;
+    int i;
 
-	for (i = 0; i < Py_SIZE(self); i++) {
-		PyObject *selfi = getarrayitem((PyObject *)self,i);
-		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
-		Py_DECREF(selfi);
-		if (cmp > 0) {
-			if (array_ass_slice(self, i, i+1,
-					   (PyObject *)NULL) != 0)
-				return NULL;
-			Py_INCREF(Py_None);
-			return Py_None;
-		}
-		else if (cmp < 0)
-			return NULL;
-	}
-	PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in list");
-	return NULL;
+    for (i = 0; i < Py_SIZE(self); i++) {
+        PyObject *selfi = getarrayitem((PyObject *)self,i);
+        int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
+        Py_DECREF(selfi);
+        if (cmp > 0) {
+            if (array_ass_slice(self, i, i+1,
+                               (PyObject *)NULL) != 0)
+                return NULL;
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+        else if (cmp < 0)
+            return NULL;
+    }
+    PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in list");
+    return NULL;
 }
 
 PyDoc_STRVAR(remove_doc,
@@ -1006,27 +1006,27 @@
 static PyObject *
 array_pop(arrayobject *self, PyObject *args)
 {
-	Py_ssize_t i = -1;
-	PyObject *v;
-	if (!PyArg_ParseTuple(args, "|n:pop", &i))
-		return NULL;
-	if (Py_SIZE(self) == 0) {
-		/* Special-case most common failure cause */
-		PyErr_SetString(PyExc_IndexError, "pop from empty array");
-		return NULL;
-	}
-	if (i < 0)
-		i += Py_SIZE(self);
-	if (i < 0 || i >= Py_SIZE(self)) {
-		PyErr_SetString(PyExc_IndexError, "pop index out of range");
-		return NULL;
-	}
-	v = getarrayitem((PyObject *)self,i);
-	if (array_ass_slice(self, i, i+1, (PyObject *)NULL) != 0) {
-		Py_DECREF(v);
-		return NULL;
-	}
-	return v;
+    Py_ssize_t i = -1;
+    PyObject *v;
+    if (!PyArg_ParseTuple(args, "|n:pop", &i))
+        return NULL;
+    if (Py_SIZE(self) == 0) {
+        /* Special-case most common failure cause */
+        PyErr_SetString(PyExc_IndexError, "pop from empty array");
+        return NULL;
+    }
+    if (i < 0)
+        i += Py_SIZE(self);
+    if (i < 0 || i >= Py_SIZE(self)) {
+        PyErr_SetString(PyExc_IndexError, "pop index out of range");
+        return NULL;
+    }
+    v = getarrayitem((PyObject *)self,i);
+    if (array_ass_slice(self, i, i+1, (PyObject *)NULL) != 0) {
+        Py_DECREF(v);
+        return NULL;
+    }
+    return v;
 }
 
 PyDoc_STRVAR(pop_doc,
@@ -1037,10 +1037,10 @@
 static PyObject *
 array_extend(arrayobject *self, PyObject *bb)
 {
-	if (array_do_extend(self, bb) == -1)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (array_do_extend(self, bb) == -1)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(extend_doc,
@@ -1051,11 +1051,11 @@
 static PyObject *
 array_insert(arrayobject *self, PyObject *args)
 {
-	Py_ssize_t i;
-	PyObject *v;
-        if (!PyArg_ParseTuple(args, "nO:insert", &i, &v))
-		return NULL;
-	return ins(self, i, v);
+    Py_ssize_t i;
+    PyObject *v;
+    if (!PyArg_ParseTuple(args, "nO:insert", &i, &v))
+        return NULL;
+    return ins(self, i, v);
 }
 
 PyDoc_STRVAR(insert_doc,
@@ -1067,15 +1067,15 @@
 static PyObject *
 array_buffer_info(arrayobject *self, PyObject *unused)
 {
-	PyObject* retval = NULL;
-	retval = PyTuple_New(2);
-	if (!retval)
-		return NULL;
+    PyObject* retval = NULL;
+    retval = PyTuple_New(2);
+    if (!retval)
+        return NULL;
 
-	PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
-	PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(Py_SIZE(self))));
+    PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
+    PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(Py_SIZE(self))));
 
-	return retval;
+    return retval;
 }
 
 PyDoc_STRVAR(buffer_info_doc,
@@ -1090,7 +1090,7 @@
 static PyObject *
 array_append(arrayobject *self, PyObject *v)
 {
-	return ins(self, (int) Py_SIZE(self), v);
+    return ins(self, (int) Py_SIZE(self), v);
 }
 
 PyDoc_STRVAR(append_doc,
@@ -1102,52 +1102,52 @@
 static PyObject *
 array_byteswap(arrayobject *self, PyObject *unused)
 {
-	char *p;
-	Py_ssize_t i;
+    char *p;
+    Py_ssize_t i;
 
-	switch (self->ob_descr->itemsize) {
-	case 1:
-		break;
-	case 2:
-		for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 2) {
-			char p0 = p[0];
-			p[0] = p[1];
-			p[1] = p0;
-		}
-		break;
-	case 4:
-		for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 4) {
-			char p0 = p[0];
-			char p1 = p[1];
-			p[0] = p[3];
-			p[1] = p[2];
-			p[2] = p1;
-			p[3] = p0;
-		}
-		break;
-	case 8:
-		for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 8) {
-			char p0 = p[0];
-			char p1 = p[1];
-			char p2 = p[2];
-			char p3 = p[3];
-			p[0] = p[7];
-			p[1] = p[6];
-			p[2] = p[5];
-			p[3] = p[4];
-			p[4] = p3;
-			p[5] = p2;
-			p[6] = p1;
-			p[7] = p0;
-		}
-		break;
-	default:
-		PyErr_SetString(PyExc_RuntimeError,
-			   "don't know how to byteswap this array type");
-		return NULL;
-	}
-	Py_INCREF(Py_None);
-	return Py_None;
+    switch (self->ob_descr->itemsize) {
+    case 1:
+        break;
+    case 2:
+        for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 2) {
+            char p0 = p[0];
+            p[0] = p[1];
+            p[1] = p0;
+        }
+        break;
+    case 4:
+        for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 4) {
+            char p0 = p[0];
+            char p1 = p[1];
+            p[0] = p[3];
+            p[1] = p[2];
+            p[2] = p1;
+            p[3] = p0;
+        }
+        break;
+    case 8:
+        for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 8) {
+            char p0 = p[0];
+            char p1 = p[1];
+            char p2 = p[2];
+            char p3 = p[3];
+            p[0] = p[7];
+            p[1] = p[6];
+            p[2] = p[5];
+            p[3] = p[4];
+            p[4] = p3;
+            p[5] = p2;
+            p[6] = p1;
+            p[7] = p0;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_RuntimeError,
+                   "don't know how to byteswap this array type");
+        return NULL;
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(byteswap_doc,
@@ -1159,28 +1159,28 @@
 static PyObject *
 array_reverse(arrayobject *self, PyObject *unused)
 {
-	register Py_ssize_t itemsize = self->ob_descr->itemsize;
-	register char *p, *q;
-	/* little buffer to hold items while swapping */
-	char tmp[256];	/* 8 is probably enough -- but why skimp */
-	assert((size_t)itemsize <= sizeof(tmp));
+    register Py_ssize_t itemsize = self->ob_descr->itemsize;
+    register char *p, *q;
+    /* little buffer to hold items while swapping */
+    char tmp[256];      /* 8 is probably enough -- but why skimp */
+    assert((size_t)itemsize <= sizeof(tmp));
 
-	if (Py_SIZE(self) > 1) {
-		for (p = self->ob_item,
-		     q = self->ob_item + (Py_SIZE(self) - 1)*itemsize;
-		     p < q;
-		     p += itemsize, q -= itemsize) {
-			/* memory areas guaranteed disjoint, so memcpy
-			 * is safe (& memmove may be slower).
-			 */
-			memcpy(tmp, p, itemsize);
-			memcpy(p, q, itemsize);
-			memcpy(q, tmp, itemsize);
-		}
-	}
+    if (Py_SIZE(self) > 1) {
+        for (p = self->ob_item,
+             q = self->ob_item + (Py_SIZE(self) - 1)*itemsize;
+             p < q;
+             p += itemsize, q -= itemsize) {
+            /* memory areas guaranteed disjoint, so memcpy
+             * is safe (& memmove may be slower).
+             */
+            memcpy(tmp, p, itemsize);
+            memcpy(p, q, itemsize);
+            memcpy(q, tmp, itemsize);
+        }
+    }
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(reverse_doc,
@@ -1191,50 +1191,50 @@
 static PyObject *
 array_fromfile(arrayobject *self, PyObject *args)
 {
-	PyObject *f;
-	Py_ssize_t n;
-	FILE *fp;
-        if (!PyArg_ParseTuple(args, "On:fromfile", &f, &n))
-		return NULL;
-	fp = PyFile_AsFile(f);
-	if (fp == NULL) {
-		PyErr_SetString(PyExc_TypeError, "arg1 must be open file");
-		return NULL;
-	}
-	if (n > 0) {
-		char *item = self->ob_item;
-		Py_ssize_t itemsize = self->ob_descr->itemsize;
-		size_t nread;
-		Py_ssize_t newlength;
-		size_t newbytes;
-		/* Be careful here about overflow */
-		if ((newlength = Py_SIZE(self) + n) <= 0 ||
-		    (newbytes = newlength * itemsize) / itemsize !=
-		    (size_t)newlength)
-			goto nomem;
-		PyMem_RESIZE(item, char, newbytes);
-		if (item == NULL) {
-		  nomem:
-			PyErr_NoMemory();
-			return NULL;
-		}
-		self->ob_item = item;
-		Py_SIZE(self) += n;
-		self->allocated = Py_SIZE(self);
-		nread = fread(item + (Py_SIZE(self) - n) * itemsize,
-			      itemsize, n, fp);
-		if (nread < (size_t)n) {
-		  Py_SIZE(self) -= (n - nread);
-			PyMem_RESIZE(item, char, Py_SIZE(self)*itemsize);
-			self->ob_item = item;
-			self->allocated = Py_SIZE(self);
-			PyErr_SetString(PyExc_EOFError,
-				         "not enough items in file");
-			return NULL;
-		}
-	}
-	Py_INCREF(Py_None);
-	return Py_None;
+    PyObject *f;
+    Py_ssize_t n;
+    FILE *fp;
+    if (!PyArg_ParseTuple(args, "On:fromfile", &f, &n))
+        return NULL;
+    fp = PyFile_AsFile(f);
+    if (fp == NULL) {
+        PyErr_SetString(PyExc_TypeError, "arg1 must be open file");
+        return NULL;
+    }
+    if (n > 0) {
+        char *item = self->ob_item;
+        Py_ssize_t itemsize = self->ob_descr->itemsize;
+        size_t nread;
+        Py_ssize_t newlength;
+        size_t newbytes;
+        /* Be careful here about overflow */
+        if ((newlength = Py_SIZE(self) + n) <= 0 ||
+            (newbytes = newlength * itemsize) / itemsize !=
+            (size_t)newlength)
+            goto nomem;
+        PyMem_RESIZE(item, char, newbytes);
+        if (item == NULL) {
+          nomem:
+            PyErr_NoMemory();
+            return NULL;
+        }
+        self->ob_item = item;
+        Py_SIZE(self) += n;
+        self->allocated = Py_SIZE(self);
+        nread = fread(item + (Py_SIZE(self) - n) * itemsize,
+                      itemsize, n, fp);
+        if (nread < (size_t)n) {
+          Py_SIZE(self) -= (n - nread);
+            PyMem_RESIZE(item, char, Py_SIZE(self)*itemsize);
+            self->ob_item = item;
+            self->allocated = Py_SIZE(self);
+            PyErr_SetString(PyExc_EOFError,
+                             "not enough items in file");
+            return NULL;
+        }
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(fromfile_doc,
@@ -1247,33 +1247,33 @@
 static PyObject *
 array_fromfile_as_read(arrayobject *self, PyObject *args)
 {
-	if (PyErr_WarnPy3k("array.read() not supported in 3.x; "
-			   "use array.fromfile()", 1) < 0)
-		return NULL;
-	return array_fromfile(self, args);
+    if (PyErr_WarnPy3k("array.read() not supported in 3.x; "
+                       "use array.fromfile()", 1) < 0)
+        return NULL;
+    return array_fromfile(self, args);
 }
 
 
 static PyObject *
 array_tofile(arrayobject *self, PyObject *f)
 {
-	FILE *fp;
+    FILE *fp;
 
-	fp = PyFile_AsFile(f);
-	if (fp == NULL) {
-		PyErr_SetString(PyExc_TypeError, "arg must be open file");
-		return NULL;
-	}
-	if (self->ob_size > 0) {
-		if (fwrite(self->ob_item, self->ob_descr->itemsize,
-			   self->ob_size, fp) != (size_t)self->ob_size) {
-			PyErr_SetFromErrno(PyExc_IOError);
-			clearerr(fp);
-			return NULL;
-		}
-	}
-	Py_INCREF(Py_None);
-	return Py_None;
+    fp = PyFile_AsFile(f);
+    if (fp == NULL) {
+        PyErr_SetString(PyExc_TypeError, "arg must be open file");
+        return NULL;
+    }
+    if (self->ob_size > 0) {
+        if (fwrite(self->ob_item, self->ob_descr->itemsize,
+                   self->ob_size, fp) != (size_t)self->ob_size) {
+            PyErr_SetFromErrno(PyExc_IOError);
+            clearerr(fp);
+            return NULL;
+        }
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(tofile_doc,
@@ -1286,53 +1286,53 @@
 static PyObject *
 array_tofile_as_write(arrayobject *self, PyObject *f)
 {
-	if (PyErr_WarnPy3k("array.write() not supported in 3.x; "
-			   "use array.tofile()", 1) < 0)
-		return NULL;
-	return array_tofile(self, f);
+    if (PyErr_WarnPy3k("array.write() not supported in 3.x; "
+                       "use array.tofile()", 1) < 0)
+        return NULL;
+    return array_tofile(self, f);
 }
 
 
 static PyObject *
 array_fromlist(arrayobject *self, PyObject *list)
 {
-	Py_ssize_t n;
-	Py_ssize_t itemsize = self->ob_descr->itemsize;
+    Py_ssize_t n;
+    Py_ssize_t itemsize = self->ob_descr->itemsize;
 
-	if (!PyList_Check(list)) {
-		PyErr_SetString(PyExc_TypeError, "arg must be list");
-		return NULL;
-	}
-	n = PyList_Size(list);
-	if (n > 0) {
-		char *item = self->ob_item;
-		Py_ssize_t i;
-		PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
-		if (item == NULL) {
-			PyErr_NoMemory();
-			return NULL;
-		}
-		self->ob_item = item;
-		Py_SIZE(self) += n;
-		self->allocated = Py_SIZE(self);
-		for (i = 0; i < n; i++) {
-			PyObject *v = PyList_GetItem(list, i);
-			if ((*self->ob_descr->setitem)(self,
-					Py_SIZE(self) - n + i, v) != 0) {
-				Py_SIZE(self) -= n;
-				if (itemsize && (self->ob_size > PY_SSIZE_T_MAX / itemsize)) {
-					return PyErr_NoMemory();
-				}
-				PyMem_RESIZE(item, char,
-					          Py_SIZE(self) * itemsize);
-				self->ob_item = item;
-				self->allocated = Py_SIZE(self);
-				return NULL;
-			}
-		}
-	}
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyList_Check(list)) {
+        PyErr_SetString(PyExc_TypeError, "arg must be list");
+        return NULL;
+    }
+    n = PyList_Size(list);
+    if (n > 0) {
+        char *item = self->ob_item;
+        Py_ssize_t i;
+        PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
+        if (item == NULL) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+        self->ob_item = item;
+        Py_SIZE(self) += n;
+        self->allocated = Py_SIZE(self);
+        for (i = 0; i < n; i++) {
+            PyObject *v = PyList_GetItem(list, i);
+            if ((*self->ob_descr->setitem)(self,
+                            Py_SIZE(self) - n + i, v) != 0) {
+                Py_SIZE(self) -= n;
+                if (itemsize && (self->ob_size > PY_SSIZE_T_MAX / itemsize)) {
+                    return PyErr_NoMemory();
+                }
+                PyMem_RESIZE(item, char,
+                                  Py_SIZE(self) * itemsize);
+                self->ob_item = item;
+                self->allocated = Py_SIZE(self);
+                return NULL;
+            }
+        }
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(fromlist_doc,
@@ -1344,20 +1344,20 @@
 static PyObject *
 array_tolist(arrayobject *self, PyObject *unused)
 {
-	PyObject *list = PyList_New(Py_SIZE(self));
-	Py_ssize_t i;
+    PyObject *list = PyList_New(Py_SIZE(self));
+    Py_ssize_t i;
 
-	if (list == NULL)
-		return NULL;
-	for (i = 0; i < Py_SIZE(self); i++) {
-		PyObject *v = getarrayitem((PyObject *)self, i);
-		if (v == NULL) {
-			Py_DECREF(list);
-			return NULL;
-		}
-		PyList_SetItem(list, i, v);
-	}
-	return list;
+    if (list == NULL)
+        return NULL;
+    for (i = 0; i < Py_SIZE(self); i++) {
+        PyObject *v = getarrayitem((PyObject *)self, i);
+        if (v == NULL) {
+            Py_DECREF(list);
+            return NULL;
+        }
+        PyList_SetItem(list, i, v);
+    }
+    return list;
 }
 
 PyDoc_STRVAR(tolist_doc,
@@ -1369,36 +1369,36 @@
 static PyObject *
 array_fromstring(arrayobject *self, PyObject *args)
 {
-	char *str;
-	Py_ssize_t n;
-	int itemsize = self->ob_descr->itemsize;
-        if (!PyArg_ParseTuple(args, "s#:fromstring", &str, &n))
-		return NULL;
-	if (n % itemsize != 0) {
-		PyErr_SetString(PyExc_ValueError,
-			   "string length not a multiple of item size");
-		return NULL;
-	}
-	n = n / itemsize;
-	if (n > 0) {
-		char *item = self->ob_item;
-		if ((n > PY_SSIZE_T_MAX - Py_SIZE(self)) ||
-			((Py_SIZE(self) + n) > PY_SSIZE_T_MAX / itemsize)) {
-				return PyErr_NoMemory();
-		}
-		PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
-		if (item == NULL) {
-			PyErr_NoMemory();
-			return NULL;
-		}
-		self->ob_item = item;
-		Py_SIZE(self) += n;
-		self->allocated = Py_SIZE(self);
-		memcpy(item + (Py_SIZE(self) - n) * itemsize,
-		       str, itemsize*n);
-	}
-	Py_INCREF(Py_None);
-	return Py_None;
+    char *str;
+    Py_ssize_t n;
+    int itemsize = self->ob_descr->itemsize;
+    if (!PyArg_ParseTuple(args, "s#:fromstring", &str, &n))
+        return NULL;
+    if (n % itemsize != 0) {
+        PyErr_SetString(PyExc_ValueError,
+                   "string length not a multiple of item size");
+        return NULL;
+    }
+    n = n / itemsize;
+    if (n > 0) {
+        char *item = self->ob_item;
+        if ((n > PY_SSIZE_T_MAX - Py_SIZE(self)) ||
+            ((Py_SIZE(self) + n) > PY_SSIZE_T_MAX / itemsize)) {
+                return PyErr_NoMemory();
+        }
+        PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
+        if (item == NULL) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+        self->ob_item = item;
+        Py_SIZE(self) += n;
+        self->allocated = Py_SIZE(self);
+        memcpy(item + (Py_SIZE(self) - n) * itemsize,
+               str, itemsize*n);
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(fromstring_doc,
@@ -1411,12 +1411,12 @@
 static PyObject *
 array_tostring(arrayobject *self, PyObject *unused)
 {
-	if (self->ob_size <= PY_SSIZE_T_MAX / self->ob_descr->itemsize) {
-		return PyString_FromStringAndSize(self->ob_item,
-				    Py_SIZE(self) * self->ob_descr->itemsize);
-	} else {
-		return PyErr_NoMemory();
-	}
+    if (self->ob_size <= PY_SSIZE_T_MAX / self->ob_descr->itemsize) {
+        return PyString_FromStringAndSize(self->ob_item,
+                            Py_SIZE(self) * self->ob_descr->itemsize);
+    } else {
+        return PyErr_NoMemory();
+    }
 }
 
 PyDoc_STRVAR(tostring_doc,
@@ -1431,36 +1431,36 @@
 static PyObject *
 array_fromunicode(arrayobject *self, PyObject *args)
 {
-	Py_UNICODE *ustr;
-	Py_ssize_t n;
+    Py_UNICODE *ustr;
+    Py_ssize_t n;
 
-        if (!PyArg_ParseTuple(args, "u#:fromunicode", &ustr, &n))
-		return NULL;
-	if (self->ob_descr->typecode != 'u') {
-		PyErr_SetString(PyExc_ValueError,
-			"fromunicode() may only be called on "
-			"type 'u' arrays");
-		return NULL;
-	}
-	if (n > 0) {
-		Py_UNICODE *item = (Py_UNICODE *) self->ob_item;
-		if (Py_SIZE(self) > PY_SSIZE_T_MAX - n) {
-			return PyErr_NoMemory();
-		}
-		PyMem_RESIZE(item, Py_UNICODE, Py_SIZE(self) + n);
-		if (item == NULL) {
-			PyErr_NoMemory();
-			return NULL;
-		}
-		self->ob_item = (char *) item;
-		Py_SIZE(self) += n;
-		self->allocated = Py_SIZE(self);
-		memcpy(item + Py_SIZE(self) - n,
-		       ustr, n * sizeof(Py_UNICODE));
-	}
+    if (!PyArg_ParseTuple(args, "u#:fromunicode", &ustr, &n))
+        return NULL;
+    if (self->ob_descr->typecode != 'u') {
+        PyErr_SetString(PyExc_ValueError,
+            "fromunicode() may only be called on "
+            "type 'u' arrays");
+        return NULL;
+    }
+    if (n > 0) {
+        Py_UNICODE *item = (Py_UNICODE *) self->ob_item;
+        if (Py_SIZE(self) > PY_SSIZE_T_MAX - n) {
+            return PyErr_NoMemory();
+        }
+        PyMem_RESIZE(item, Py_UNICODE, Py_SIZE(self) + n);
+        if (item == NULL) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+        self->ob_item = (char *) item;
+        Py_SIZE(self) += n;
+        self->allocated = Py_SIZE(self);
+        memcpy(item + Py_SIZE(self) - n,
+               ustr, n * sizeof(Py_UNICODE));
+    }
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(fromunicode_doc,
@@ -1475,12 +1475,12 @@
 static PyObject *
 array_tounicode(arrayobject *self, PyObject *unused)
 {
-	if (self->ob_descr->typecode != 'u') {
-		PyErr_SetString(PyExc_ValueError,
-			"tounicode() may only be called on type 'u' arrays");
-		return NULL;
-	}
-	return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_SIZE(self));
+    if (self->ob_descr->typecode != 'u') {
+        PyErr_SetString(PyExc_ValueError,
+            "tounicode() may only be called on type 'u' arrays");
+        return NULL;
+    }
+    return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_SIZE(self));
 }
 
 PyDoc_STRVAR(tounicode_doc,
@@ -1496,32 +1496,32 @@
 static PyObject *
 array_reduce(arrayobject *array)
 {
-	PyObject *dict, *result, *list;
+    PyObject *dict, *result, *list;
 
-	dict = PyObject_GetAttrString((PyObject *)array, "__dict__");
-	if (dict == NULL) {
-		if (!PyErr_ExceptionMatches(PyExc_AttributeError))
-			return NULL;
-		PyErr_Clear();
-		dict = Py_None;
-		Py_INCREF(dict);
-	}
-	/* Unlike in Python 3.x, we never use the more efficient memory
-	 * representation of an array for pickling.  This is unfortunately
-	 * necessary to allow array objects to be unpickled by Python 3.x,
-	 * since str objects from 2.x are always decoded to unicode in
-	 * Python 3.x.
-	 */
-	list = array_tolist(array, NULL);
-	if (list == NULL) {
-		Py_DECREF(dict);
-		return NULL;
-	}
-	result = Py_BuildValue(
-		"O(cO)O", Py_TYPE(array), array->ob_descr->typecode, list, dict);
-	Py_DECREF(list);
-	Py_DECREF(dict);
-	return result;
+    dict = PyObject_GetAttrString((PyObject *)array, "__dict__");
+    if (dict == NULL) {
+        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+            return NULL;
+        PyErr_Clear();
+        dict = Py_None;
+        Py_INCREF(dict);
+    }
+    /* Unlike in Python 3.x, we never use the more efficient memory
+     * representation of an array for pickling.  This is unfortunately
+     * necessary to allow array objects to be unpickled by Python 3.x,
+     * since str objects from 2.x are always decoded to unicode in
+     * Python 3.x.
+     */
+    list = array_tolist(array, NULL);
+    if (list == NULL) {
+        Py_DECREF(dict);
+        return NULL;
+    }
+    result = Py_BuildValue(
+        "O(cO)O", Py_TYPE(array), array->ob_descr->typecode, list, dict);
+    Py_DECREF(list);
+    Py_DECREF(dict);
+    return result;
 }
 
 PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
@@ -1529,321 +1529,321 @@
 static PyObject *
 array_get_typecode(arrayobject *a, void *closure)
 {
-	char tc = a->ob_descr->typecode;
-	return PyString_FromStringAndSize(&tc, 1);
+    char tc = a->ob_descr->typecode;
+    return PyString_FromStringAndSize(&tc, 1);
 }
 
 static PyObject *
 array_get_itemsize(arrayobject *a, void *closure)
 {
-	return PyInt_FromLong((long)a->ob_descr->itemsize);
+    return PyInt_FromLong((long)a->ob_descr->itemsize);
 }
 
 static PyGetSetDef array_getsets [] = {
-	{"typecode", (getter) array_get_typecode, NULL,
-	 "the typecode character used to create the array"},
-	{"itemsize", (getter) array_get_itemsize, NULL,
-	 "the size, in bytes, of one array item"},
-	{NULL}
+    {"typecode", (getter) array_get_typecode, NULL,
+     "the typecode character used to create the array"},
+    {"itemsize", (getter) array_get_itemsize, NULL,
+     "the size, in bytes, of one array item"},
+    {NULL}
 };
 
 static PyMethodDef array_methods[] = {
-	{"append",	(PyCFunction)array_append,	METH_O,
-	 append_doc},
-	{"buffer_info", (PyCFunction)array_buffer_info, METH_NOARGS,
-	 buffer_info_doc},
-	{"byteswap",	(PyCFunction)array_byteswap,	METH_NOARGS,
-	 byteswap_doc},
-	{"__copy__",	(PyCFunction)array_copy,	METH_NOARGS,
-	 copy_doc},
-	{"count",	(PyCFunction)array_count,	METH_O,
-	 count_doc},
-	{"__deepcopy__",(PyCFunction)array_copy,	METH_O,
-	 copy_doc},
-	{"extend",      (PyCFunction)array_extend,	METH_O,
-	 extend_doc},
-	{"fromfile",	(PyCFunction)array_fromfile,	METH_VARARGS,
-	 fromfile_doc},
-	{"fromlist",	(PyCFunction)array_fromlist,	METH_O,
-	 fromlist_doc},
-	{"fromstring",	(PyCFunction)array_fromstring,	METH_VARARGS,
-	 fromstring_doc},
+    {"append",          (PyCFunction)array_append,      METH_O,
+     append_doc},
+    {"buffer_info", (PyCFunction)array_buffer_info, METH_NOARGS,
+     buffer_info_doc},
+    {"byteswap",        (PyCFunction)array_byteswap,    METH_NOARGS,
+     byteswap_doc},
+    {"__copy__",        (PyCFunction)array_copy,        METH_NOARGS,
+     copy_doc},
+    {"count",           (PyCFunction)array_count,       METH_O,
+     count_doc},
+    {"__deepcopy__",(PyCFunction)array_copy,            METH_O,
+     copy_doc},
+    {"extend",      (PyCFunction)array_extend,          METH_O,
+     extend_doc},
+    {"fromfile",        (PyCFunction)array_fromfile,    METH_VARARGS,
+     fromfile_doc},
+    {"fromlist",        (PyCFunction)array_fromlist,    METH_O,
+     fromlist_doc},
+    {"fromstring",      (PyCFunction)array_fromstring,  METH_VARARGS,
+     fromstring_doc},
 #ifdef Py_USING_UNICODE
-	{"fromunicode",	(PyCFunction)array_fromunicode,	METH_VARARGS,
-	 fromunicode_doc},
+    {"fromunicode",     (PyCFunction)array_fromunicode, METH_VARARGS,
+     fromunicode_doc},
 #endif
-	{"index",	(PyCFunction)array_index,	METH_O,
-	 index_doc},
-	{"insert",	(PyCFunction)array_insert,	METH_VARARGS,
-	 insert_doc},
-	{"pop",		(PyCFunction)array_pop,		METH_VARARGS,
-	 pop_doc},
-	{"read",	(PyCFunction)array_fromfile_as_read,	METH_VARARGS,
-	 fromfile_doc},
-	{"__reduce__",	(PyCFunction)array_reduce,	METH_NOARGS,
-	 reduce_doc},
-	{"remove",	(PyCFunction)array_remove,	METH_O,
-	 remove_doc},
-	{"reverse",	(PyCFunction)array_reverse,	METH_NOARGS,
-	 reverse_doc},
-/*	{"sort",	(PyCFunction)array_sort,	METH_VARARGS,
-	sort_doc},*/
-	{"tofile",	(PyCFunction)array_tofile,	METH_O,
-	 tofile_doc},
-	{"tolist",	(PyCFunction)array_tolist,	METH_NOARGS,
-	 tolist_doc},
-	{"tostring",	(PyCFunction)array_tostring,	METH_NOARGS,
-	 tostring_doc},
+    {"index",           (PyCFunction)array_index,       METH_O,
+     index_doc},
+    {"insert",          (PyCFunction)array_insert,      METH_VARARGS,
+     insert_doc},
+    {"pop",             (PyCFunction)array_pop,         METH_VARARGS,
+     pop_doc},
+    {"read",            (PyCFunction)array_fromfile_as_read,    METH_VARARGS,
+     fromfile_doc},
+    {"__reduce__",      (PyCFunction)array_reduce,      METH_NOARGS,
+     reduce_doc},
+    {"remove",          (PyCFunction)array_remove,      METH_O,
+     remove_doc},
+    {"reverse",         (PyCFunction)array_reverse,     METH_NOARGS,
+     reverse_doc},
+/*      {"sort",        (PyCFunction)array_sort,        METH_VARARGS,
+    sort_doc},*/
+    {"tofile",          (PyCFunction)array_tofile,      METH_O,
+     tofile_doc},
+    {"tolist",          (PyCFunction)array_tolist,      METH_NOARGS,
+     tolist_doc},
+    {"tostring",        (PyCFunction)array_tostring,    METH_NOARGS,
+     tostring_doc},
 #ifdef Py_USING_UNICODE
-	{"tounicode",   (PyCFunction)array_tounicode,	METH_NOARGS,
-	 tounicode_doc},
+    {"tounicode",   (PyCFunction)array_tounicode,       METH_NOARGS,
+     tounicode_doc},
 #endif
-	{"write",	(PyCFunction)array_tofile_as_write,	METH_O,
-	 tofile_doc},
-	{NULL,		NULL}		/* sentinel */
+    {"write",           (PyCFunction)array_tofile_as_write,     METH_O,
+     tofile_doc},
+    {NULL,              NULL}           /* sentinel */
 };
 
 static PyObject *
 array_repr(arrayobject *a)
 {
-	char buf[256], typecode;
-	PyObject *s, *t, *v = NULL;
-	Py_ssize_t len;
+    char buf[256], typecode;
+    PyObject *s, *t, *v = NULL;
+    Py_ssize_t len;
 
-	len = Py_SIZE(a);
-	typecode = a->ob_descr->typecode;
-	if (len == 0) {
-		PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode);
-		return PyString_FromString(buf);
-	}
-		
-	if (typecode == 'c')
-		v = array_tostring(a, NULL);
+    len = Py_SIZE(a);
+    typecode = a->ob_descr->typecode;
+    if (len == 0) {
+        PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode);
+        return PyString_FromString(buf);
+    }
+
+    if (typecode == 'c')
+        v = array_tostring(a, NULL);
 #ifdef Py_USING_UNICODE
-	else if (typecode == 'u')
-		v = array_tounicode(a, NULL);
+    else if (typecode == 'u')
+        v = array_tounicode(a, NULL);
 #endif
-	else
-		v = array_tolist(a, NULL);
-	t = PyObject_Repr(v);
-	Py_XDECREF(v);
+    else
+        v = array_tolist(a, NULL);
+    t = PyObject_Repr(v);
+    Py_XDECREF(v);
 
-	PyOS_snprintf(buf, sizeof(buf), "array('%c', ", typecode);
-	s = PyString_FromString(buf);
-	PyString_ConcatAndDel(&s, t);
-	PyString_ConcatAndDel(&s, PyString_FromString(")"));
-	return s;
+    PyOS_snprintf(buf, sizeof(buf), "array('%c', ", typecode);
+    s = PyString_FromString(buf);
+    PyString_ConcatAndDel(&s, t);
+    PyString_ConcatAndDel(&s, PyString_FromString(")"));
+    return s;
 }
 
 static PyObject*
 array_subscr(arrayobject* self, PyObject* item)
 {
-	if (PyIndex_Check(item)) {
-		Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
-		if (i==-1 && PyErr_Occurred()) {
-			return NULL;
-		}
-		if (i < 0)
-			i += Py_SIZE(self);
-		return array_item(self, i);
-	}
-	else if (PySlice_Check(item)) {
-		Py_ssize_t start, stop, step, slicelength, cur, i;
-		PyObject* result;
-		arrayobject* ar;
-		int itemsize = self->ob_descr->itemsize;
+    if (PyIndex_Check(item)) {
+        Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
+        if (i==-1 && PyErr_Occurred()) {
+            return NULL;
+        }
+        if (i < 0)
+            i += Py_SIZE(self);
+        return array_item(self, i);
+    }
+    else if (PySlice_Check(item)) {
+        Py_ssize_t start, stop, step, slicelength, cur, i;
+        PyObject* result;
+        arrayobject* ar;
+        int itemsize = self->ob_descr->itemsize;
 
-		if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
-				 &start, &stop, &step, &slicelength) < 0) {
-			return NULL;
-		}
+        if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
+                         &start, &stop, &step, &slicelength) < 0) {
+            return NULL;
+        }
 
-		if (slicelength <= 0) {
-			return newarrayobject(&Arraytype, 0, self->ob_descr);
-		}
-		else if (step == 1) {
-			PyObject *result = newarrayobject(&Arraytype,
-						slicelength, self->ob_descr);
-			if (result == NULL)
-				return NULL;
-			memcpy(((arrayobject *)result)->ob_item,
-			       self->ob_item + start * itemsize,
-			       slicelength * itemsize);
-			return result;
-		}
-		else {
-			result = newarrayobject(&Arraytype, slicelength, self->ob_descr);
-			if (!result) return NULL;
+        if (slicelength <= 0) {
+            return newarrayobject(&Arraytype, 0, self->ob_descr);
+        }
+        else if (step == 1) {
+            PyObject *result = newarrayobject(&Arraytype,
+                                    slicelength, self->ob_descr);
+            if (result == NULL)
+                return NULL;
+            memcpy(((arrayobject *)result)->ob_item,
+                   self->ob_item + start * itemsize,
+                   slicelength * itemsize);
+            return result;
+        }
+        else {
+            result = newarrayobject(&Arraytype, slicelength, self->ob_descr);
+            if (!result) return NULL;
 
-			ar = (arrayobject*)result;
+            ar = (arrayobject*)result;
 
-			for (cur = start, i = 0; i < slicelength; 
-			     cur += step, i++) {
-				memcpy(ar->ob_item + i*itemsize,
-				       self->ob_item + cur*itemsize,
-				       itemsize);
-			}
-			
-			return result;
-		}		
-	}
-	else {
-		PyErr_SetString(PyExc_TypeError, 
-				"array indices must be integers");
-		return NULL;
-	}
+            for (cur = start, i = 0; i < slicelength;
+                 cur += step, i++) {
+                memcpy(ar->ob_item + i*itemsize,
+                       self->ob_item + cur*itemsize,
+                       itemsize);
+            }
+
+            return result;
+        }
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "array indices must be integers");
+        return NULL;
+    }
 }
 
 static int
 array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
 {
-	Py_ssize_t start, stop, step, slicelength, needed;
-	arrayobject* other;
-	int itemsize;
+    Py_ssize_t start, stop, step, slicelength, needed;
+    arrayobject* other;
+    int itemsize;
 
-	if (PyIndex_Check(item)) {
-		Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
-		
-		if (i == -1 && PyErr_Occurred())
-			return -1;
-		if (i < 0)
-			i += Py_SIZE(self);
-		if (i < 0 || i >= Py_SIZE(self)) {
-			PyErr_SetString(PyExc_IndexError,
-				"array assignment index out of range");
-			return -1;
-		}
-		if (value == NULL) {
-			/* Fall through to slice assignment */
-			start = i;
-			stop = i + 1;
-			step = 1;
-			slicelength = 1;
-		}
-		else
-			return (*self->ob_descr->setitem)(self, i, value);
-	}
-	else if (PySlice_Check(item)) {
-		if (PySlice_GetIndicesEx((PySliceObject *)item,
-					 Py_SIZE(self), &start, &stop,
-					 &step, &slicelength) < 0) {
-			return -1;
-		}
-	}
-	else {
-		PyErr_SetString(PyExc_TypeError,
-				"array indices must be integer");
-		return -1;
-	}
-	if (value == NULL) {
-		other = NULL;
-		needed = 0;
-	}
-	else if (array_Check(value)) {
-		other = (arrayobject *)value;
-		needed = Py_SIZE(other);
-		if (self == other) {
-			/* Special case "self[i:j] = self" -- copy self first */
-			int ret;
-			value = array_slice(other, 0, needed);
-			if (value == NULL)
-				return -1;
-			ret = array_ass_subscr(self, item, value);
-			Py_DECREF(value);
-			return ret;
-		}
-		if (other->ob_descr != self->ob_descr) {
-			PyErr_BadArgument();
-			return -1;
-		}
-	}
-	else {
-		PyErr_Format(PyExc_TypeError,
-	     "can only assign array (not \"%.200s\") to array slice",
-			     Py_TYPE(value)->tp_name);
-		return -1;
-	}
-	itemsize = self->ob_descr->itemsize;
-	/* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */
-	if ((step > 0 && stop < start) ||
-	    (step < 0 && stop > start))
-		stop = start;
-	if (step == 1) {
-		if (slicelength > needed) {
-			memmove(self->ob_item + (start + needed) * itemsize,
-				self->ob_item + stop * itemsize,
-				(Py_SIZE(self) - stop) * itemsize);
-			if (array_resize(self, Py_SIZE(self) +
-					 needed - slicelength) < 0)
-				return -1;
-		}
-		else if (slicelength < needed) {
-			if (array_resize(self, Py_SIZE(self) +
-					 needed - slicelength) < 0)
-				return -1;
-			memmove(self->ob_item + (start + needed) * itemsize,
-				self->ob_item + stop * itemsize,
-				(Py_SIZE(self) - start - needed) * itemsize);
-		}
-		if (needed > 0)
-			memcpy(self->ob_item + start * itemsize,
-			       other->ob_item, needed * itemsize);
-		return 0;
-	}
-	else if (needed == 0) {
-		/* Delete slice */
-		size_t cur;
-		Py_ssize_t i;
+    if (PyIndex_Check(item)) {
+        Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
 
-		if (step < 0) {
-			stop = start + 1;
-			start = stop + step * (slicelength - 1) - 1;
-			step = -step;
-		}
-		for (cur = start, i = 0; i < slicelength;
-		     cur += step, i++) {
-			Py_ssize_t lim = step - 1;
+        if (i == -1 && PyErr_Occurred())
+            return -1;
+        if (i < 0)
+            i += Py_SIZE(self);
+        if (i < 0 || i >= Py_SIZE(self)) {
+            PyErr_SetString(PyExc_IndexError,
+                "array assignment index out of range");
+            return -1;
+        }
+        if (value == NULL) {
+            /* Fall through to slice assignment */
+            start = i;
+            stop = i + 1;
+            step = 1;
+            slicelength = 1;
+        }
+        else
+            return (*self->ob_descr->setitem)(self, i, value);
+    }
+    else if (PySlice_Check(item)) {
+        if (PySlice_GetIndicesEx((PySliceObject *)item,
+                                 Py_SIZE(self), &start, &stop,
+                                 &step, &slicelength) < 0) {
+            return -1;
+        }
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "array indices must be integer");
+        return -1;
+    }
+    if (value == NULL) {
+        other = NULL;
+        needed = 0;
+    }
+    else if (array_Check(value)) {
+        other = (arrayobject *)value;
+        needed = Py_SIZE(other);
+        if (self == other) {
+            /* Special case "self[i:j] = self" -- copy self first */
+            int ret;
+            value = array_slice(other, 0, needed);
+            if (value == NULL)
+                return -1;
+            ret = array_ass_subscr(self, item, value);
+            Py_DECREF(value);
+            return ret;
+        }
+        if (other->ob_descr != self->ob_descr) {
+            PyErr_BadArgument();
+            return -1;
+        }
+    }
+    else {
+        PyErr_Format(PyExc_TypeError,
+         "can only assign array (not \"%.200s\") to array slice",
+                         Py_TYPE(value)->tp_name);
+        return -1;
+    }
+    itemsize = self->ob_descr->itemsize;
+    /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */
+    if ((step > 0 && stop < start) ||
+        (step < 0 && stop > start))
+        stop = start;
+    if (step == 1) {
+        if (slicelength > needed) {
+            memmove(self->ob_item + (start + needed) * itemsize,
+                self->ob_item + stop * itemsize,
+                (Py_SIZE(self) - stop) * itemsize);
+            if (array_resize(self, Py_SIZE(self) +
+                             needed - slicelength) < 0)
+                return -1;
+        }
+        else if (slicelength < needed) {
+            if (array_resize(self, Py_SIZE(self) +
+                             needed - slicelength) < 0)
+                return -1;
+            memmove(self->ob_item + (start + needed) * itemsize,
+                self->ob_item + stop * itemsize,
+                (Py_SIZE(self) - start - needed) * itemsize);
+        }
+        if (needed > 0)
+            memcpy(self->ob_item + start * itemsize,
+                   other->ob_item, needed * itemsize);
+        return 0;
+    }
+    else if (needed == 0) {
+        /* Delete slice */
+        size_t cur;
+        Py_ssize_t i;
 
-			if (cur + step >= (size_t)Py_SIZE(self))
-				lim = Py_SIZE(self) - cur - 1;
-			memmove(self->ob_item + (cur - i) * itemsize,
-				self->ob_item + (cur + 1) * itemsize,
-				lim * itemsize);
-		}
-		cur = start + slicelength * step;
-		if (cur < (size_t)Py_SIZE(self)) {
-			memmove(self->ob_item + (cur-slicelength) * itemsize,
-				self->ob_item + cur * itemsize,
-				(Py_SIZE(self) - cur) * itemsize);
-		}
-		if (array_resize(self, Py_SIZE(self) - slicelength) < 0)
-			return -1;
-		return 0;
-	}
-	else {
-		Py_ssize_t cur, i;
+        if (step < 0) {
+            stop = start + 1;
+            start = stop + step * (slicelength - 1) - 1;
+            step = -step;
+        }
+        for (cur = start, i = 0; i < slicelength;
+             cur += step, i++) {
+            Py_ssize_t lim = step - 1;
 
-		if (needed != slicelength) {
-			PyErr_Format(PyExc_ValueError,
-				"attempt to assign array of size %zd "
-				"to extended slice of size %zd",
-				needed, slicelength);
-			return -1;
-		}
-		for (cur = start, i = 0; i < slicelength;
-		     cur += step, i++) {
-			memcpy(self->ob_item + cur * itemsize,
-			       other->ob_item + i * itemsize,
-			       itemsize);
-		}
-		return 0;
-	}
+            if (cur + step >= (size_t)Py_SIZE(self))
+                lim = Py_SIZE(self) - cur - 1;
+            memmove(self->ob_item + (cur - i) * itemsize,
+                self->ob_item + (cur + 1) * itemsize,
+                lim * itemsize);
+        }
+        cur = start + slicelength * step;
+        if (cur < (size_t)Py_SIZE(self)) {
+            memmove(self->ob_item + (cur-slicelength) * itemsize,
+                self->ob_item + cur * itemsize,
+                (Py_SIZE(self) - cur) * itemsize);
+        }
+        if (array_resize(self, Py_SIZE(self) - slicelength) < 0)
+            return -1;
+        return 0;
+    }
+    else {
+        Py_ssize_t cur, i;
+
+        if (needed != slicelength) {
+            PyErr_Format(PyExc_ValueError,
+                "attempt to assign array of size %zd "
+                "to extended slice of size %zd",
+                needed, slicelength);
+            return -1;
+        }
+        for (cur = start, i = 0; i < slicelength;
+             cur += step, i++) {
+            memcpy(self->ob_item + cur * itemsize,
+                   other->ob_item + i * itemsize,
+                   itemsize);
+        }
+        return 0;
+    }
 }
 
 static PyMappingMethods array_as_mapping = {
-	(lenfunc)array_length,
-	(binaryfunc)array_subscr,
-	(objobjargproc)array_ass_subscr
+    (lenfunc)array_length,
+    (binaryfunc)array_subscr,
+    (objobjargproc)array_ass_subscr
 };
 
 static const void *emptybuf = "";
@@ -1851,164 +1851,164 @@
 static Py_ssize_t
 array_buffer_getreadbuf(arrayobject *self, Py_ssize_t index, const void **ptr)
 {
-	if ( index != 0 ) {
-		PyErr_SetString(PyExc_SystemError,
-				"Accessing non-existent array segment");
-		return -1;
-	}
-	*ptr = (void *)self->ob_item;
-	if (*ptr == NULL)
-		*ptr = emptybuf;
-	return Py_SIZE(self)*self->ob_descr->itemsize;
+    if ( index != 0 ) {
+        PyErr_SetString(PyExc_SystemError,
+                        "Accessing non-existent array segment");
+        return -1;
+    }
+    *ptr = (void *)self->ob_item;
+    if (*ptr == NULL)
+        *ptr = emptybuf;
+    return Py_SIZE(self)*self->ob_descr->itemsize;
 }
 
 static Py_ssize_t
 array_buffer_getwritebuf(arrayobject *self, Py_ssize_t index, const void **ptr)
 {
-	if ( index != 0 ) {
-		PyErr_SetString(PyExc_SystemError,
-				"Accessing non-existent array segment");
-		return -1;
-	}
-	*ptr = (void *)self->ob_item;
-	if (*ptr == NULL)
-		*ptr = emptybuf;
-	return Py_SIZE(self)*self->ob_descr->itemsize;
+    if ( index != 0 ) {
+        PyErr_SetString(PyExc_SystemError,
+                        "Accessing non-existent array segment");
+        return -1;
+    }
+    *ptr = (void *)self->ob_item;
+    if (*ptr == NULL)
+        *ptr = emptybuf;
+    return Py_SIZE(self)*self->ob_descr->itemsize;
 }
 
 static Py_ssize_t
 array_buffer_getsegcount(arrayobject *self, Py_ssize_t *lenp)
 {
-	if ( lenp )
-		*lenp = Py_SIZE(self)*self->ob_descr->itemsize;
-	return 1;
+    if ( lenp )
+        *lenp = Py_SIZE(self)*self->ob_descr->itemsize;
+    return 1;
 }
 
 static PySequenceMethods array_as_sequence = {
-	(lenfunc)array_length,		        /*sq_length*/
-	(binaryfunc)array_concat,               /*sq_concat*/
-	(ssizeargfunc)array_repeat,		/*sq_repeat*/
-	(ssizeargfunc)array_item,		        /*sq_item*/
-	(ssizessizeargfunc)array_slice,		/*sq_slice*/
-	(ssizeobjargproc)array_ass_item,		/*sq_ass_item*/
-	(ssizessizeobjargproc)array_ass_slice,	/*sq_ass_slice*/
-	(objobjproc)array_contains,		/*sq_contains*/
-	(binaryfunc)array_inplace_concat,	/*sq_inplace_concat*/
-	(ssizeargfunc)array_inplace_repeat	/*sq_inplace_repeat*/
+    (lenfunc)array_length,                      /*sq_length*/
+    (binaryfunc)array_concat,               /*sq_concat*/
+    (ssizeargfunc)array_repeat,                 /*sq_repeat*/
+    (ssizeargfunc)array_item,                           /*sq_item*/
+    (ssizessizeargfunc)array_slice,             /*sq_slice*/
+    (ssizeobjargproc)array_ass_item,                    /*sq_ass_item*/
+    (ssizessizeobjargproc)array_ass_slice,      /*sq_ass_slice*/
+    (objobjproc)array_contains,                 /*sq_contains*/
+    (binaryfunc)array_inplace_concat,           /*sq_inplace_concat*/
+    (ssizeargfunc)array_inplace_repeat          /*sq_inplace_repeat*/
 };
 
 static PyBufferProcs array_as_buffer = {
-	(readbufferproc)array_buffer_getreadbuf,
-	(writebufferproc)array_buffer_getwritebuf,
-	(segcountproc)array_buffer_getsegcount,
-	NULL,
+    (readbufferproc)array_buffer_getreadbuf,
+    (writebufferproc)array_buffer_getwritebuf,
+    (segcountproc)array_buffer_getsegcount,
+    NULL,
 };
 
 static PyObject *
 array_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
-	char c;
-	PyObject *initial = NULL, *it = NULL;
-	struct arraydescr *descr;
-	
-	if (type == &Arraytype && !_PyArg_NoKeywords("array.array()", kwds))
-		return NULL;
+    char c;
+    PyObject *initial = NULL, *it = NULL;
+    struct arraydescr *descr;
 
-	if (!PyArg_ParseTuple(args, "c|O:array", &c, &initial))
-		return NULL;
+    if (type == &Arraytype && !_PyArg_NoKeywords("array.array()", kwds))
+        return NULL;
 
-	if (!(initial == NULL || PyList_Check(initial)
-	      || PyString_Check(initial) || PyTuple_Check(initial)
-	      || (c == 'u' && PyUnicode_Check(initial)))) {
-		it = PyObject_GetIter(initial);
-		if (it == NULL)
-			return NULL;
-		/* We set initial to NULL so that the subsequent code
-		   will create an empty array of the appropriate type
-		   and afterwards we can use array_iter_extend to populate
-		   the array.
-		*/
-		initial = NULL;
-	}
-	for (descr = descriptors; descr->typecode != '\0'; descr++) {
-		if (descr->typecode == c) {
-			PyObject *a;
-			Py_ssize_t len;
+    if (!PyArg_ParseTuple(args, "c|O:array", &c, &initial))
+        return NULL;
 
-			if (initial == NULL || !(PyList_Check(initial) 
-				|| PyTuple_Check(initial)))
-				len = 0;
-			else
-				len = PySequence_Size(initial);
+    if (!(initial == NULL || PyList_Check(initial)
+          || PyString_Check(initial) || PyTuple_Check(initial)
+          || (c == 'u' && PyUnicode_Check(initial)))) {
+        it = PyObject_GetIter(initial);
+        if (it == NULL)
+            return NULL;
+        /* We set initial to NULL so that the subsequent code
+           will create an empty array of the appropriate type
+           and afterwards we can use array_iter_extend to populate
+           the array.
+        */
+        initial = NULL;
+    }
+    for (descr = descriptors; descr->typecode != '\0'; descr++) {
+        if (descr->typecode == c) {
+            PyObject *a;
+            Py_ssize_t len;
 
-			a = newarrayobject(type, len, descr);
-			if (a == NULL)
-				return NULL;
+            if (initial == NULL || !(PyList_Check(initial)
+                || PyTuple_Check(initial)))
+                len = 0;
+            else
+                len = PySequence_Size(initial);
 
-			if (len > 0) {
-				Py_ssize_t i;
-				for (i = 0; i < len; i++) {
-					PyObject *v =
-					        PySequence_GetItem(initial, i);
-					if (v == NULL) {
-						Py_DECREF(a);
-						return NULL;
-					}
-					if (setarrayitem(a, i, v) != 0) {
-						Py_DECREF(v);
-						Py_DECREF(a);
-						return NULL;
-					}
-					Py_DECREF(v);
-				}
-			} else if (initial != NULL && PyString_Check(initial)) {
-				PyObject *t_initial, *v;
-				t_initial = PyTuple_Pack(1, initial);
-				if (t_initial == NULL) {
-					Py_DECREF(a);
-					return NULL;
-				}
-				v = array_fromstring((arrayobject *)a,
-							 t_initial);
-				Py_DECREF(t_initial);
-				if (v == NULL) {
-					Py_DECREF(a);
-					return NULL;
-				}
-				Py_DECREF(v);
+            a = newarrayobject(type, len, descr);
+            if (a == NULL)
+                return NULL;
+
+            if (len > 0) {
+                Py_ssize_t i;
+                for (i = 0; i < len; i++) {
+                    PyObject *v =
+                        PySequence_GetItem(initial, i);
+                    if (v == NULL) {
+                        Py_DECREF(a);
+                        return NULL;
+                    }
+                    if (setarrayitem(a, i, v) != 0) {
+                        Py_DECREF(v);
+                        Py_DECREF(a);
+                        return NULL;
+                    }
+                    Py_DECREF(v);
+                }
+            } else if (initial != NULL && PyString_Check(initial)) {
+                PyObject *t_initial, *v;
+                t_initial = PyTuple_Pack(1, initial);
+                if (t_initial == NULL) {
+                    Py_DECREF(a);
+                    return NULL;
+                }
+                v = array_fromstring((arrayobject *)a,
+                                         t_initial);
+                Py_DECREF(t_initial);
+                if (v == NULL) {
+                    Py_DECREF(a);
+                    return NULL;
+                }
+                Py_DECREF(v);
 #ifdef Py_USING_UNICODE
-			} else if (initial != NULL && PyUnicode_Check(initial))  {
-				Py_ssize_t n = PyUnicode_GET_DATA_SIZE(initial);
-				if (n > 0) {
-					arrayobject *self = (arrayobject *)a;
-					char *item = self->ob_item;
-					item = (char *)PyMem_Realloc(item, n);
-					if (item == NULL) {
-						PyErr_NoMemory();
-						Py_DECREF(a);
-						return NULL;
-					}
-					self->ob_item = item;
-					Py_SIZE(self) = n / sizeof(Py_UNICODE);
-					memcpy(item, PyUnicode_AS_DATA(initial), n);
-					self->allocated = Py_SIZE(self);
-				}
+            } else if (initial != NULL && PyUnicode_Check(initial))  {
+                Py_ssize_t n = PyUnicode_GET_DATA_SIZE(initial);
+                if (n > 0) {
+                    arrayobject *self = (arrayobject *)a;
+                    char *item = self->ob_item;
+                    item = (char *)PyMem_Realloc(item, n);
+                    if (item == NULL) {
+                        PyErr_NoMemory();
+                        Py_DECREF(a);
+                        return NULL;
+                    }
+                    self->ob_item = item;
+                    Py_SIZE(self) = n / sizeof(Py_UNICODE);
+                    memcpy(item, PyUnicode_AS_DATA(initial), n);
+                    self->allocated = Py_SIZE(self);
+                }
 #endif
-			}
-			if (it != NULL) {
-				if (array_iter_extend((arrayobject *)a, it) == -1) {
-					Py_DECREF(it);
-					Py_DECREF(a);
-					return NULL;
-				}
-				Py_DECREF(it);
-			}
-			return a;
-		}
-	}
-	PyErr_SetString(PyExc_ValueError,
-		"bad typecode (must be c, b, B, u, h, H, i, I, l, L, f or d)");
-	return NULL;
+            }
+            if (it != NULL) {
+                if (array_iter_extend((arrayobject *)a, it) == -1) {
+                    Py_DECREF(it);
+                    Py_DECREF(a);
+                    return NULL;
+                }
+                Py_DECREF(it);
+            }
+            return a;
+        }
+    }
+    PyErr_SetString(PyExc_ValueError,
+        "bad typecode (must be c, b, B, u, h, H, i, I, l, L, f or d)");
+    return NULL;
 }
 
 
@@ -2079,55 +2079,55 @@
 static PyObject *array_iter(arrayobject *ao);
 
 static PyTypeObject Arraytype = {
-	PyVarObject_HEAD_INIT(NULL, 0)
-	"array.array",
-	sizeof(arrayobject),
-	0,
-	(destructor)array_dealloc,		/* tp_dealloc */
-	0,					/* tp_print */
-	0,					/* tp_getattr */
-	0,					/* tp_setattr */
-	0,					/* tp_compare */
-	(reprfunc)array_repr,			/* tp_repr */
-	0,					/* tp_as_number*/
-	&array_as_sequence,			/* tp_as_sequence*/
-	&array_as_mapping,			/* tp_as_mapping*/
-	0, 					/* tp_hash */
-	0,					/* tp_call */
-	0,					/* tp_str */
-	PyObject_GenericGetAttr,		/* tp_getattro */
-	0,					/* tp_setattro */
-	&array_as_buffer,			/* tp_as_buffer*/
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS,  /* tp_flags */
-	arraytype_doc,				/* tp_doc */
- 	0,					/* tp_traverse */
-	0,					/* tp_clear */
-	array_richcompare,			/* tp_richcompare */
-	offsetof(arrayobject, weakreflist),	/* tp_weaklistoffset */
-	(getiterfunc)array_iter,		/* tp_iter */
-	0,					/* tp_iternext */
-	array_methods,				/* tp_methods */
-	0,					/* tp_members */
-	array_getsets,				/* tp_getset */
-	0,					/* tp_base */
-	0,					/* tp_dict */
-	0,					/* tp_descr_get */
-	0,					/* tp_descr_set */
-	0,					/* tp_dictoffset */
-	0,					/* tp_init */
-	PyType_GenericAlloc,			/* tp_alloc */
-	array_new,				/* tp_new */
-	PyObject_Del,				/* tp_free */
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "array.array",
+    sizeof(arrayobject),
+    0,
+    (destructor)array_dealloc,                  /* tp_dealloc */
+    0,                                          /* tp_print */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+    0,                                          /* tp_compare */
+    (reprfunc)array_repr,                       /* tp_repr */
+    0,                                          /* tp_as_number*/
+    &array_as_sequence,                         /* tp_as_sequence*/
+    &array_as_mapping,                          /* tp_as_mapping*/
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    PyObject_GenericGetAttr,                    /* tp_getattro */
+    0,                                          /* tp_setattro */
+    &array_as_buffer,                           /* tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS,  /* tp_flags */
+    arraytype_doc,                              /* tp_doc */
+    0,                                          /* tp_traverse */
+    0,                                          /* tp_clear */
+    array_richcompare,                          /* tp_richcompare */
+    offsetof(arrayobject, weakreflist),         /* tp_weaklistoffset */
+    (getiterfunc)array_iter,                    /* tp_iter */
+    0,                                          /* tp_iternext */
+    array_methods,                              /* tp_methods */
+    0,                                          /* tp_members */
+    array_getsets,                              /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    0,                                          /* tp_descr_get */
+    0,                                          /* tp_descr_set */
+    0,                                          /* tp_dictoffset */
+    0,                                          /* tp_init */
+    PyType_GenericAlloc,                        /* tp_alloc */
+    array_new,                                  /* tp_new */
+    PyObject_Del,                               /* tp_free */
 };
 
 
 /*********************** Array Iterator **************************/
 
 typedef struct {
-	PyObject_HEAD
-	Py_ssize_t			index;
-	arrayobject		*ao;
-	PyObject		* (*getitem)(struct arrayobject *, Py_ssize_t);
+    PyObject_HEAD
+    Py_ssize_t                          index;
+    arrayobject                 *ao;
+    PyObject                    * (*getitem)(struct arrayobject *, Py_ssize_t);
 } arrayiterobject;
 
 static PyTypeObject PyArrayIter_Type;
@@ -2137,79 +2137,79 @@
 static PyObject *
 array_iter(arrayobject *ao)
 {
-	arrayiterobject *it;
+    arrayiterobject *it;
 
-	if (!array_Check(ao)) {
-		PyErr_BadInternalCall();
-		return NULL;
-	}
+    if (!array_Check(ao)) {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
 
-	it = PyObject_GC_New(arrayiterobject, &PyArrayIter_Type);
-	if (it == NULL)
-		return NULL;
+    it = PyObject_GC_New(arrayiterobject, &PyArrayIter_Type);
+    if (it == NULL)
+        return NULL;
 
-	Py_INCREF(ao);
-	it->ao = ao;
-	it->index = 0;
-	it->getitem = ao->ob_descr->getitem;
-	PyObject_GC_Track(it);
-	return (PyObject *)it;
+    Py_INCREF(ao);
+    it->ao = ao;
+    it->index = 0;
+    it->getitem = ao->ob_descr->getitem;
+    PyObject_GC_Track(it);
+    return (PyObject *)it;
 }
 
 static PyObject *
 arrayiter_next(arrayiterobject *it)
 {
-	assert(PyArrayIter_Check(it));
-	if (it->index < Py_SIZE(it->ao))
-		return (*it->getitem)(it->ao, it->index++);
-	return NULL;
+    assert(PyArrayIter_Check(it));
+    if (it->index < Py_SIZE(it->ao))
+        return (*it->getitem)(it->ao, it->index++);
+    return NULL;
 }
 
 static void
 arrayiter_dealloc(arrayiterobject *it)
 {
-	PyObject_GC_UnTrack(it);
-	Py_XDECREF(it->ao);
-	PyObject_GC_Del(it);
+    PyObject_GC_UnTrack(it);
+    Py_XDECREF(it->ao);
+    PyObject_GC_Del(it);
 }
 
 static int
 arrayiter_traverse(arrayiterobject *it, visitproc visit, void *arg)
 {
-	Py_VISIT(it->ao);
-	return 0;
+    Py_VISIT(it->ao);
+    return 0;
 }
 
 static PyTypeObject PyArrayIter_Type = {
-	PyVarObject_HEAD_INIT(NULL, 0)
-	"arrayiterator",                        /* tp_name */
-	sizeof(arrayiterobject),                /* tp_basicsize */
-	0,                                      /* tp_itemsize */
-	/* methods */
-	(destructor)arrayiter_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 */
-	PyObject_GenericGetAttr,                /* tp_getattro */
-	0,                                      /* tp_setattro */
-	0,                                      /* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
-	0,                                      /* tp_doc */
-	(traverseproc)arrayiter_traverse,	/* tp_traverse */
-	0,					/* tp_clear */
-	0,                                      /* tp_richcompare */
-	0,                                      /* tp_weaklistoffset */
-	PyObject_SelfIter,			/* tp_iter */
-	(iternextfunc)arrayiter_next,		/* tp_iternext */
-	0,					/* tp_methods */
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "arrayiterator",                        /* tp_name */
+    sizeof(arrayiterobject),                /* tp_basicsize */
+    0,                                      /* tp_itemsize */
+    /* methods */
+    (destructor)arrayiter_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 */
+    PyObject_GenericGetAttr,                /* tp_getattro */
+    0,                                      /* tp_setattro */
+    0,                                      /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
+    0,                                      /* tp_doc */
+    (traverseproc)arrayiter_traverse,           /* tp_traverse */
+    0,                                          /* tp_clear */
+    0,                                      /* tp_richcompare */
+    0,                                      /* tp_weaklistoffset */
+    PyObject_SelfIter,                          /* tp_iter */
+    (iternextfunc)arrayiter_next,               /* tp_iternext */
+    0,                                          /* tp_methods */
 };
 
 
@@ -2224,17 +2224,17 @@
 PyMODINIT_FUNC
 initarray(void)
 {
-	PyObject *m;
+    PyObject *m;
 
-	Arraytype.ob_type = &PyType_Type;
-	PyArrayIter_Type.ob_type = &PyType_Type;
-	m = Py_InitModule3("array", a_methods, module_doc);
-	if (m == NULL)
-		return;
+    Arraytype.ob_type = &PyType_Type;
+    PyArrayIter_Type.ob_type = &PyType_Type;
+    m = Py_InitModule3("array", a_methods, module_doc);
+    if (m == NULL)
+        return;
 
-        Py_INCREF((PyObject *)&Arraytype);
-	PyModule_AddObject(m, "ArrayType", (PyObject *)&Arraytype);
-        Py_INCREF((PyObject *)&Arraytype);
-	PyModule_AddObject(m, "array", (PyObject *)&Arraytype);
-	/* No need to check the error here, the caller will do that */
+    Py_INCREF((PyObject *)&Arraytype);
+    PyModule_AddObject(m, "ArrayType", (PyObject *)&Arraytype);
+    Py_INCREF((PyObject *)&Arraytype);
+    PyModule_AddObject(m, "array", (PyObject *)&Arraytype);
+    /* No need to check the error here, the caller will do that */
 }