Fix whitespace to conform to Python 3000 convention.

1 files changed, 8753 insertions, 8754 deletions

diff --git a/numpy/core/src/arrayobject.c b/numpy/core/src/arrayobject.c
index e269195cc..2847b7796 100644
--- a/numpy/core/src/arrayobject.c
+++ b/numpy/core/src/arrayobject.c
@@ -1,142 +1,141 @@
-
 /*
   Provide multidimensional arrays as a basic object type in python.
 
-Based on Original Numeric implementation
-Copyright (c) 1995, 1996, 1997 Jim Hugunin, hugunin@mit.edu
+  Based on Original Numeric implementation
+  Copyright (c) 1995, 1996, 1997 Jim Hugunin, hugunin@mit.edu
 
-with contributions from many Numeric Python developers 1995-2004
+  with contributions from many Numeric Python developers 1995-2004
 
-Heavily modified in 2005 with inspiration from Numarray
+  Heavily modified in 2005 with inspiration from Numarray
 
-by
+  by
 
-Travis Oliphant,  oliphant@ee.byu.edu
-Brigham Young Univeristy
+  Travis Oliphant,  oliphant@ee.byu.edu
+  Brigham Young Univeristy
 
-maintainer email:  oliphant.travis@ieee.org
+  maintainer email:  oliphant.travis@ieee.org
 
-Numarray design (which provided guidance) by
-Space Science Telescope Institute
+  Numarray design (which provided guidance) by
+  Space Science Telescope Institute
   (J. Todd Miller, Perry Greenfield, Rick White)
 */
 
 /*OBJECT_API
- Get Priority from object
+  Get Priority from object
 */
 static double
 PyArray_GetPriority(PyObject *obj, double default_)
 {
-        PyObject *ret;
-        double priority=PyArray_PRIORITY;
+    PyObject *ret;
+    double priority=PyArray_PRIORITY;
 
-        if (PyArray_CheckExact(obj))
-                return priority;
-
-        ret = PyObject_GetAttrString(obj, "__array_priority__");
-        if (ret != NULL) priority = PyFloat_AsDouble(ret);
-        if (PyErr_Occurred()) {
-                PyErr_Clear();
-                priority = default_;
-        }
-        Py_XDECREF(ret);
+    if (PyArray_CheckExact(obj))
         return priority;
+
+    ret = PyObject_GetAttrString(obj, "__array_priority__");
+    if (ret != NULL) priority = PyFloat_AsDouble(ret);
+    if (PyErr_Occurred()) {
+        PyErr_Clear();
+        priority = default_;
+    }
+    Py_XDECREF(ret);
+    return priority;
 }
 
 static int
 _check_object_rec(PyArray_Descr *descr)
 {
-        if (PyDataType_HASFIELDS(descr) && PyDataType_REFCHK(descr)) {
-                PyErr_SetString(PyExc_TypeError, "Not supported for this data-type.");
-                return -1;
-        }
-        return 0;
+    if (PyDataType_HASFIELDS(descr) && PyDataType_REFCHK(descr)) {
+        PyErr_SetString(PyExc_TypeError, "Not supported for this data-type.");
+        return -1;
+    }
+    return 0;
 }
 
 /* Backward compatibility only */
 /* In both Zero and One
 
- ***You must free the memory once you are done with it
-    using PyDataMem_FREE(ptr) or you create a memory leak***
+***You must free the memory once you are done with it
+using PyDataMem_FREE(ptr) or you create a memory leak***
 
-    If arr is an Object array you are getting a
-    BORROWED reference to Zero or One.
-    Do not DECREF.
-    Please INCREF if you will be hanging on to it.
+If arr is an Object array you are getting a
+BORROWED reference to Zero or One.
+Do not DECREF.
+Please INCREF if you will be hanging on to it.
 
-    The memory for the ptr still must be freed in any case;
+The memory for the ptr still must be freed in any case;
 */
 
 
 /*OBJECT_API
- Get pointer to zero of correct type for array.
+  Get pointer to zero of correct type for array.
 */
 static char *
 PyArray_Zero(PyArrayObject *arr)
 {
-        char *zeroval;
-        int ret, storeflags;
-        PyObject *obj;
+    char *zeroval;
+    int ret, storeflags;
+    PyObject *obj;
 
-        if (_check_object_rec(arr->descr) < 0) return NULL;
-        zeroval = PyDataMem_NEW(arr->descr->elsize);
-        if (zeroval == NULL) {
-                PyErr_SetNone(PyExc_MemoryError);
-                return NULL;
-        }
+    if (_check_object_rec(arr->descr) < 0) return NULL;
+    zeroval = PyDataMem_NEW(arr->descr->elsize);
+    if (zeroval == NULL) {
+        PyErr_SetNone(PyExc_MemoryError);
+        return NULL;
+    }
 
-        obj=PyInt_FromLong((long) 0);
-        if (PyArray_ISOBJECT(arr)) {
-                memcpy(zeroval, &obj, sizeof(PyObject *));
-                Py_DECREF(obj);
-                return zeroval;
-        }
-        storeflags = arr->flags;
-        arr->flags |= BEHAVED;
-        ret = arr->descr->f->setitem(obj, zeroval, arr);
-        arr->flags = storeflags;
+    obj=PyInt_FromLong((long) 0);
+    if (PyArray_ISOBJECT(arr)) {
+        memcpy(zeroval, &obj, sizeof(PyObject *));
         Py_DECREF(obj);
-        if (ret < 0) {
-                PyDataMem_FREE(zeroval);
-                return NULL;
-        }
         return zeroval;
+    }
+    storeflags = arr->flags;
+    arr->flags |= BEHAVED;
+    ret = arr->descr->f->setitem(obj, zeroval, arr);
+    arr->flags = storeflags;
+    Py_DECREF(obj);
+    if (ret < 0) {
+        PyDataMem_FREE(zeroval);
+        return NULL;
+    }
+    return zeroval;
 }
 
 /*OBJECT_API
- Get pointer to one of correct type for array
+  Get pointer to one of correct type for array
 */
 static char *
 PyArray_One(PyArrayObject *arr)
 {
-        char *oneval;
-        int ret, storeflags;
-        PyObject *obj;
-
-        if (_check_object_rec(arr->descr) < 0) return NULL;
-        oneval = PyDataMem_NEW(arr->descr->elsize);
-        if (oneval == NULL) {
-                PyErr_SetNone(PyExc_MemoryError);
-                return NULL;
-        }
+    char *oneval;
+    int ret, storeflags;
+    PyObject *obj;
 
-        obj = PyInt_FromLong((long) 1);
-        if (PyArray_ISOBJECT(arr)) {
-                memcpy(oneval, &obj, sizeof(PyObject *));
-                Py_DECREF(obj);
-                return oneval;
-        }
+    if (_check_object_rec(arr->descr) < 0) return NULL;
+    oneval = PyDataMem_NEW(arr->descr->elsize);
+    if (oneval == NULL) {
+        PyErr_SetNone(PyExc_MemoryError);
+        return NULL;
+    }
 
-        storeflags = arr->flags;
-        arr->flags |= BEHAVED;
-        ret = arr->descr->f->setitem(obj, oneval, arr);
-        arr->flags = storeflags;
+    obj = PyInt_FromLong((long) 1);
+    if (PyArray_ISOBJECT(arr)) {
+        memcpy(oneval, &obj, sizeof(PyObject *));
         Py_DECREF(obj);
-        if (ret < 0) {
-                PyDataMem_FREE(oneval);
-                return NULL;
-        }
         return oneval;
+    }
+
+    storeflags = arr->flags;
+    arr->flags |= BEHAVED;
+    ret = arr->descr->f->setitem(obj, oneval, arr);
+    arr->flags = storeflags;
+    Py_DECREF(obj);
+    if (ret < 0) {
+        PyDataMem_FREE(oneval);
+        return NULL;
+    }
+    return oneval;
 }
 
 /* End deprecated */
@@ -152,26 +151,26 @@ static PyObject *PyArray_New(PyTypeObject *, int nd, intp *,
 static void
 PyArray_Item_INCREF(char *data, PyArray_Descr *descr)
 {
-        PyObject **temp;
+    PyObject **temp;
 
-        if (!PyDataType_REFCHK(descr)) return;
+    if (!PyDataType_REFCHK(descr)) return;
 
-        if (descr->type_num == PyArray_OBJECT) {
-                temp = (PyObject **)data;
-                Py_XINCREF(*temp);
-        }
-        else if (PyDescr_HASFIELDS(descr)) {
-                PyObject *key, *value, *title=NULL;
-                PyArray_Descr *new;
-                int offset;
-                Py_ssize_t pos=0;
-                while (PyDict_Next(descr->fields, &pos, &key, &value)) {
-                        if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
-                                              &title)) return;
-                        PyArray_Item_INCREF(data + offset, new);
-                }
+    if (descr->type_num == PyArray_OBJECT) {
+        temp = (PyObject **)data;
+        Py_XINCREF(*temp);
+    }
+    else if (PyDescr_HASFIELDS(descr)) {
+        PyObject *key, *value, *title=NULL;
+        PyArray_Descr *new;
+        int offset;
+        Py_ssize_t pos=0;
+        while (PyDict_Next(descr->fields, &pos, &key, &value)) {
+            if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
+                                  &title)) return;
+            PyArray_Item_INCREF(data + offset, new);
         }
-        return;
+    }
+    return;
 }
 
 /* XDECREF all objects found at this record */
@@ -180,26 +179,26 @@ PyArray_Item_INCREF(char *data, PyArray_Descr *descr)
 static void
 PyArray_Item_XDECREF(char *data, PyArray_Descr *descr)
 {
-        PyObject **temp;
+    PyObject **temp;
 
-        if (!PyDataType_REFCHK(descr)) return;
+    if (!PyDataType_REFCHK(descr)) return;
 
-        if (descr->type_num == PyArray_OBJECT) {
-                temp = (PyObject **)data;
-                Py_XDECREF(*temp);
-        }
-        else if PyDescr_HASFIELDS(descr) {
-                PyObject *key, *value, *title=NULL;
-                PyArray_Descr *new;
-                int offset;
-                Py_ssize_t pos=0;
-                while (PyDict_Next(descr->fields, &pos, &key, &value)) {
-                        if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
-                                              &title)) return;
-                        PyArray_Item_XDECREF(data + offset, new);
-                }
+    if (descr->type_num == PyArray_OBJECT) {
+        temp = (PyObject **)data;
+        Py_XDECREF(*temp);
+    }
+    else if PyDescr_HASFIELDS(descr) {
+            PyObject *key, *value, *title=NULL;
+            PyArray_Descr *new;
+            int offset;
+            Py_ssize_t pos=0;
+            while (PyDict_Next(descr->fields, &pos, &key, &value)) {
+                if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
+                                      &title)) return;
+                PyArray_Item_XDECREF(data + offset, new);
+            }
         }
-        return;
+    return;
 }
 
 /* C-API functions */
@@ -207,147 +206,147 @@ PyArray_Item_XDECREF(char *data, PyArray_Descr *descr)
 /* Used for arrays of python objects to increment the reference count of */
 /* every python object in the array. */
 /*OBJECT_API
- For object arrays, increment all internal references.
+  For object arrays, increment all internal references.
 */
 static int
 PyArray_INCREF(PyArrayObject *mp)
 {
-        intp i, n;
-        PyObject **data, **temp;
-        PyArrayIterObject *it;
+    intp i, n;
+    PyObject **data, **temp;
+    PyArrayIterObject *it;
 
-        if (!PyDataType_REFCHK(mp->descr)) return 0;
+    if (!PyDataType_REFCHK(mp->descr)) return 0;
 
-        if (mp->descr->type_num != PyArray_OBJECT) {
-                it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
-                if (it == NULL) return -1;
-                while(it->index < it->size) {
-                        PyArray_Item_INCREF(it->dataptr, mp->descr);
-                        PyArray_ITER_NEXT(it);
-                }
-                Py_DECREF(it);
-                return 0;
+    if (mp->descr->type_num != PyArray_OBJECT) {
+        it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
+        if (it == NULL) return -1;
+        while(it->index < it->size) {
+            PyArray_Item_INCREF(it->dataptr, mp->descr);
+            PyArray_ITER_NEXT(it);
         }
+        Py_DECREF(it);
+        return 0;
+    }
 
-        if (PyArray_ISONESEGMENT(mp)) {
-                data = (PyObject **)mp->data;
-                n = PyArray_SIZE(mp);
-                if (PyArray_ISALIGNED(mp)) {
-                        for(i=0; i<n; i++, data++) Py_XINCREF(*data);
-                }
-                else {
-                        for (i=0; i<n; i++, data++) {
-                                temp = data;
-                                Py_XINCREF(*temp);
-                        }
-                }
+    if (PyArray_ISONESEGMENT(mp)) {
+        data = (PyObject **)mp->data;
+        n = PyArray_SIZE(mp);
+        if (PyArray_ISALIGNED(mp)) {
+            for(i=0; i<n; i++, data++) Py_XINCREF(*data);
         }
-        else { /* handles misaligned data too */
-                it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
-                if (it == NULL) return -1;
-                while(it->index < it->size) {
-                        temp = (PyObject **)it->dataptr;
-                        Py_XINCREF(*temp);
-                        PyArray_ITER_NEXT(it);
-                }
-                Py_DECREF(it);
+        else {
+            for (i=0; i<n; i++, data++) {
+                temp = data;
+                Py_XINCREF(*temp);
+            }
         }
-        return 0;
+    }
+    else { /* handles misaligned data too */
+        it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
+        if (it == NULL) return -1;
+        while(it->index < it->size) {
+            temp = (PyObject **)it->dataptr;
+            Py_XINCREF(*temp);
+            PyArray_ITER_NEXT(it);
+        }
+        Py_DECREF(it);
+    }
+    return 0;
 }
 
 /*OBJECT_API
- Decrement all internal references for object arrays.
- (or arrays with object fields)
+  Decrement all internal references for object arrays.
+  (or arrays with object fields)
 */
 static int
 PyArray_XDECREF(PyArrayObject *mp)
 {
-        intp i, n;
-        PyObject **data;
-        PyObject **temp;
-        PyArrayIterObject *it;
+    intp i, n;
+    PyObject **data;
+    PyObject **temp;
+    PyArrayIterObject *it;
 
-        if (!PyDataType_REFCHK(mp->descr)) return 0;
+    if (!PyDataType_REFCHK(mp->descr)) return 0;
 
-        if (mp->descr->type_num != PyArray_OBJECT) {
-                it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
-                if (it == NULL) return -1;
-                while(it->index < it->size) {
-                        PyArray_Item_XDECREF(it->dataptr, mp->descr);
-                        PyArray_ITER_NEXT(it);
-                }
-                Py_DECREF(it);
-                return 0;
+    if (mp->descr->type_num != PyArray_OBJECT) {
+        it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
+        if (it == NULL) return -1;
+        while(it->index < it->size) {
+            PyArray_Item_XDECREF(it->dataptr, mp->descr);
+            PyArray_ITER_NEXT(it);
         }
+        Py_DECREF(it);
+        return 0;
+    }
 
-        if (PyArray_ISONESEGMENT(mp)) {
-                data = (PyObject **)mp->data;
-                n = PyArray_SIZE(mp);
-                if (PyArray_ISALIGNED(mp)) {
-                        for(i=0; i<n; i++, data++) Py_XDECREF(*data);
-                }
-                else {
-                        for (i=0; i<n; i++, data++) {
-                                temp = data;
-                                Py_XDECREF(*temp);
-                        }
-                }
+    if (PyArray_ISONESEGMENT(mp)) {
+        data = (PyObject **)mp->data;
+        n = PyArray_SIZE(mp);
+        if (PyArray_ISALIGNED(mp)) {
+            for(i=0; i<n; i++, data++) Py_XDECREF(*data);
         }
-        else { /* handles misaligned data too */
-                it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
-                if (it == NULL) return -1;
-                while(it->index < it->size) {
-                        temp = (PyObject **)it->dataptr;
-                        Py_XDECREF(*temp);
-                        PyArray_ITER_NEXT(it);
-                }
-                Py_DECREF(it);
+        else {
+            for (i=0; i<n; i++, data++) {
+                temp = data;
+                Py_XDECREF(*temp);
+            }
         }
-        return 0;
+    }
+    else { /* handles misaligned data too */
+        it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
+        if (it == NULL) return -1;
+        while(it->index < it->size) {
+            temp = (PyObject **)it->dataptr;
+            Py_XDECREF(*temp);
+            PyArray_ITER_NEXT(it);
+        }
+        Py_DECREF(it);
+    }
+    return 0;
 }
 
 static void
 _strided_byte_copy(char *dst, intp outstrides, char *src, intp instrides,
                    intp N, int elsize)
 {
-        intp i, j;
-        char *tout = dst;
-        char *tin = src;
-
-#define _FAST_MOVE(_type_)                                  \
-        for (i=0; i<N; i++) {                               \
-                ((_type_ *)tout)[0] = ((_type_ *)tin)[0];   \
-                tin += instrides;                           \
-                tout += outstrides;                         \
-        }                                                   \
-        return
-
-        switch(elsize) {
-        case 8:
-                _FAST_MOVE(Int64);
-        case 4:
-                _FAST_MOVE(Int32);
-        case 1:
-                _FAST_MOVE(Int8);
-        case 2:
-                _FAST_MOVE(Int16);
-        case 16:
-                for (i=0; i<N; i++) {
-                        ((Int64 *)tout)[0] = ((Int64 *)tin)[0];
-                        ((Int64 *)tout)[1] = ((Int64 *)tin)[1];
-                        tin += instrides;
-                        tout += outstrides;
-                }
-                return;
-        default:
-                for (i=0; i<N; i++) {
-                        for (j=0; j<elsize; j++) {
-                                *tout++ = *tin++;
-                        }
-                        tin = tin + instrides - elsize;
-                        tout = tout + outstrides - elsize;
-                }
+    intp i, j;
+    char *tout = dst;
+    char *tin = src;
+
+#define _FAST_MOVE(_type_)                              \
+    for (i=0; i<N; i++) {                               \
+        ((_type_ *)tout)[0] = ((_type_ *)tin)[0];       \
+        tin += instrides;                               \
+        tout += outstrides;                             \
+    }                                                   \
+    return
+
+    switch(elsize) {
+    case 8:
+        _FAST_MOVE(Int64);
+    case 4:
+        _FAST_MOVE(Int32);
+    case 1:
+        _FAST_MOVE(Int8);
+    case 2:
+        _FAST_MOVE(Int16);
+    case 16:
+        for (i=0; i<N; i++) {
+            ((Int64 *)tout)[0] = ((Int64 *)tin)[0];
+            ((Int64 *)tout)[1] = ((Int64 *)tin)[1];
+            tin += instrides;
+            tout += outstrides;
         }
+        return;
+    default:
+        for (i=0; i<N; i++) {
+            for (j=0; j<elsize; j++) {
+                *tout++ = *tin++;
+            }
+            tin = tin + instrides - elsize;
+            tout = tout + outstrides - elsize;
+        }
+    }
 #undef _FAST_MOVE
 
 }
@@ -357,33 +356,33 @@ static void
 _unaligned_strided_byte_move(char *dst, intp outstrides, char *src,
                              intp instrides, intp N, int elsize)
 {
-        intp i;
-        char *tout = dst;
-        char *tin = src;
-
-
-#define _MOVE_N_SIZE(size)                             \
-        for (i=0; i<N; i++) {                          \
-                memmove(tout, tin, size);              \
-                tin += instrides;                      \
-                tout += outstrides;                    \
-        }                                              \
-        return
-
-        switch(elsize) {
-        case 8:
-                _MOVE_N_SIZE(8);
-        case 4:
-                _MOVE_N_SIZE(4);
-        case 1:
-                _MOVE_N_SIZE(1);
-        case 2:
-                _MOVE_N_SIZE(2);
-        case 16:
-                _MOVE_N_SIZE(16);
-        default:
-                _MOVE_N_SIZE(elsize);
-        }
+    intp i;
+    char *tout = dst;
+    char *tin = src;
+
+
+#define _MOVE_N_SIZE(size)                      \
+    for (i=0; i<N; i++) {                       \
+        memmove(tout, tin, size);               \
+        tin += instrides;                       \
+        tout += outstrides;                     \
+    }                                           \
+    return
+
+    switch(elsize) {
+    case 8:
+        _MOVE_N_SIZE(8);
+    case 4:
+        _MOVE_N_SIZE(4);
+    case 1:
+        _MOVE_N_SIZE(1);
+    case 2:
+        _MOVE_N_SIZE(2);
+    case 16:
+        _MOVE_N_SIZE(16);
+    default:
+        _MOVE_N_SIZE(elsize);
+    }
 #undef _MOVE_N_SIZE
 
 }
@@ -392,32 +391,32 @@ static void
 _unaligned_strided_byte_copy(char *dst, intp outstrides, char *src,
                              intp instrides, intp N, int elsize)
 {
-        intp i;
-        char *tout = dst;
-        char *tin = src;
-
-#define _COPY_N_SIZE(size)                             \
-        for (i=0; i<N; i++) {                          \
-                memcpy(tout, tin, size);               \
-                tin += instrides;                      \
-                tout += outstrides;                    \
-        }                                              \
-        return
-
-        switch(elsize) {
-        case 8:
-                _COPY_N_SIZE(8);
-        case 4:
-                _COPY_N_SIZE(4);
-        case 1:
-                _COPY_N_SIZE(1);
-        case 2:
-                _COPY_N_SIZE(2);
-        case 16:
-                _COPY_N_SIZE(16);
-        default:
-                _COPY_N_SIZE(elsize);
-        }
+    intp i;
+    char *tout = dst;
+    char *tin = src;
+
+#define _COPY_N_SIZE(size)                      \
+    for (i=0; i<N; i++) {                       \
+        memcpy(tout, tin, size);                \
+        tin += instrides;                       \
+        tout += outstrides;                     \
+    }                                           \
+    return
+
+    switch(elsize) {
+    case 8:
+        _COPY_N_SIZE(8);
+    case 4:
+        _COPY_N_SIZE(4);
+    case 1:
+        _COPY_N_SIZE(1);
+    case 2:
+        _COPY_N_SIZE(2);
+    case 16:
+        _COPY_N_SIZE(16);
+    default:
+        _COPY_N_SIZE(elsize);
+    }
 #undef _COPY_N_SIZE
 
 }
@@ -425,51 +424,51 @@ _unaligned_strided_byte_copy(char *dst, intp outstrides, char *src,
 static void
 _strided_byte_swap(void *p, intp stride, intp n, int size)
 {
-        char *a, *b, c=0;
-        int j,m;
-
-        switch(size) {
-        case 1: /* no byteswap necessary */
-                break;
-        case 4:
-                for (a = (char*)p ; n > 0; n--, a += stride-1) {
-                        b = a + 3;
-                        c = *a; *a++ = *b; *b-- = c;
-                        c = *a; *a = *b; *b   = c;
-                }
-                break;
-        case 8:
-                for (a = (char*)p ; n > 0; n--, a += stride-3) {
-                        b = a + 7;
-                        c = *a; *a++ = *b; *b-- = c;
-                        c = *a; *a++ = *b; *b-- = c;
-                        c = *a; *a++ = *b; *b-- = c;
-                        c = *a; *a = *b; *b   = c;
-                }
-                break;
-        case 2:
-                for (a = (char*)p ; n > 0; n--, a += stride) {
-                        b = a + 1;
-                        c = *a; *a = *b; *b = c;
-                }
-                break;
-        default:
-                m = size / 2;
-                for (a = (char *)p ; n > 0; n--, a += stride-m) {
-                        b = a + (size-1);
-                        for (j=0; j<m; j++) {
-                                c=*a; *a++ = *b; *b-- = c;
-                        }
-                }
-                break;
+    char *a, *b, c=0;
+    int j,m;
+
+    switch(size) {
+    case 1: /* no byteswap necessary */
+        break;
+    case 4:
+        for (a = (char*)p ; n > 0; n--, a += stride-1) {
+            b = a + 3;
+            c = *a; *a++ = *b; *b-- = c;
+            c = *a; *a = *b; *b   = c;
+        }
+        break;
+    case 8:
+        for (a = (char*)p ; n > 0; n--, a += stride-3) {
+            b = a + 7;
+            c = *a; *a++ = *b; *b-- = c;
+            c = *a; *a++ = *b; *b-- = c;
+            c = *a; *a++ = *b; *b-- = c;
+            c = *a; *a = *b; *b   = c;
+        }
+        break;
+    case 2:
+        for (a = (char*)p ; n > 0; n--, a += stride) {
+            b = a + 1;
+            c = *a; *a = *b; *b = c;
+        }
+        break;
+    default:
+        m = size / 2;
+        for (a = (char *)p ; n > 0; n--, a += stride-m) {
+            b = a + (size-1);
+            for (j=0; j<m; j++) {
+                c=*a; *a++ = *b; *b-- = c;
+            }
         }
+        break;
+    }
 }
 
 static void
 byte_swap_vector(void *p, intp n, int size)
 {
-        _strided_byte_swap(p, (intp) size, n, size);
-        return;
+    _strided_byte_swap(p, (intp) size, n, size);
+    return;
 }
 
 /* If numitems > 1, then dst must be contiguous */
@@ -477,23 +476,23 @@ static void
 copy_and_swap(void *dst, void *src, int itemsize, intp numitems,
               intp srcstrides, int swap)
 {
-        int i;
-        char *s1 = (char *)src;
-        char *d1 = (char *)dst;
+    int i;
+    char *s1 = (char *)src;
+    char *d1 = (char *)dst;
 
 
-        if ((numitems == 1) || (itemsize == srcstrides))
-                memcpy(d1, s1, itemsize*numitems);
-        else {
-                for (i = 0; i < numitems; i++) {
-                        memcpy(d1, s1, itemsize);
-                        d1 += itemsize;
-                        s1 += srcstrides;
-                }
+    if ((numitems == 1) || (itemsize == srcstrides))
+        memcpy(d1, s1, itemsize*numitems);
+    else {
+        for (i = 0; i < numitems; i++) {
+            memcpy(d1, s1, itemsize);
+            d1 += itemsize;
+            s1 += srcstrides;
         }
+    }
 
-        if (swap)
-                byte_swap_vector(d1, numitems, itemsize);
+    if (swap)
+        byte_swap_vector(d1, numitems, itemsize);
 }
 
 
@@ -517,97 +516,97 @@ static PyArray_Descr **userdescrs=NULL;
 static intp
 PyArray_PyIntAsIntp(PyObject *o)
 {
-        longlong long_value = -1;
-        PyObject *obj;
-        static char *msg = "an integer is required";
-        PyObject *arr;
-        PyArray_Descr *descr;
-        intp ret;
+    longlong long_value = -1;
+    PyObject *obj;
+    static char *msg = "an integer is required";
+    PyObject *arr;
+    PyArray_Descr *descr;
+    intp ret;
 
-        if (!o) {
-                PyErr_SetString(PyExc_TypeError, msg);
-                return -1;
-        }
+    if (!o) {
+        PyErr_SetString(PyExc_TypeError, msg);
+        return -1;
+    }
 
-        if (PyInt_Check(o)) {
-                long_value = (longlong) PyInt_AS_LONG(o);
-                goto finish;
-        } else if (PyLong_Check(o)) {
-                long_value = (longlong) PyLong_AsLongLong(o);
-                goto finish;
-        }
+    if (PyInt_Check(o)) {
+        long_value = (longlong) PyInt_AS_LONG(o);
+        goto finish;
+    } else if (PyLong_Check(o)) {
+        long_value = (longlong) PyLong_AsLongLong(o);
+        goto finish;
+    }
 
 #if SIZEOF_INTP == SIZEOF_LONG
-        descr = &LONG_Descr;
+    descr = &LONG_Descr;
 #elif SIZEOF_INTP == SIZEOF_INT
-        descr = &INT_Descr;
+    descr = &INT_Descr;
 #else
-        descr = &LONGLONG_Descr;
+    descr = &LONGLONG_Descr;
 #endif
-        arr = NULL;
+    arr = NULL;
 
-        if (PyArray_Check(o)) {
-                if (PyArray_SIZE(o)!=1 || !PyArray_ISINTEGER(o)) {
-                        PyErr_SetString(PyExc_TypeError, msg);
-                        return -1;
-                }
-                Py_INCREF(descr);
-                arr = PyArray_CastToType((PyArrayObject *)o, descr, 0);
-        }
-        else if (PyArray_IsScalar(o, Integer)) {
-                Py_INCREF(descr);
-                arr = PyArray_FromScalar(o, descr);
-        }
-        if (arr != NULL) {
-                ret = *((intp *)PyArray_DATA(arr));
-                Py_DECREF(arr);
-                return ret;
+    if (PyArray_Check(o)) {
+        if (PyArray_SIZE(o)!=1 || !PyArray_ISINTEGER(o)) {
+            PyErr_SetString(PyExc_TypeError, msg);
+            return -1;
         }
+        Py_INCREF(descr);
+        arr = PyArray_CastToType((PyArrayObject *)o, descr, 0);
+    }
+    else if (PyArray_IsScalar(o, Integer)) {
+        Py_INCREF(descr);
+        arr = PyArray_FromScalar(o, descr);
+    }
+    if (arr != NULL) {
+        ret = *((intp *)PyArray_DATA(arr));
+        Py_DECREF(arr);
+        return ret;
+    }
 
 #if (PY_VERSION_HEX >= 0x02050000)
-	if (PyIndex_Check(o)) {
-                PyObject* value = PyNumber_Index(o);
-		if (value==NULL) {
-		  return -1;
-		}
-		long_value = (longlong) PyInt_AsSsize_t(value);
-		goto finish;
-	}
-#endif
-        if (o->ob_type->tp_as_number != NULL &&                 \
-            o->ob_type->tp_as_number->nb_long != NULL) {
-                obj = o->ob_type->tp_as_number->nb_long(o);
-                if (obj != NULL) {
-                        long_value = (longlong) PyLong_AsLongLong(obj);
-                        Py_DECREF(obj);
-                }
+    if (PyIndex_Check(o)) {
+        PyObject* value = PyNumber_Index(o);
+        if (value==NULL) {
+            return -1;
         }
-        else if (o->ob_type->tp_as_number != NULL &&            \
-                 o->ob_type->tp_as_number->nb_int != NULL) {
-                obj = o->ob_type->tp_as_number->nb_int(o);
-                if (obj != NULL) {
-                        long_value = (longlong) PyLong_AsLongLong(obj);
-                        Py_DECREF(obj);
-                }
+        long_value = (longlong) PyInt_AsSsize_t(value);
+        goto finish;
+    }
+#endif
+    if (o->ob_type->tp_as_number != NULL &&                 \
+        o->ob_type->tp_as_number->nb_long != NULL) {
+        obj = o->ob_type->tp_as_number->nb_long(o);
+        if (obj != NULL) {
+            long_value = (longlong) PyLong_AsLongLong(obj);
+            Py_DECREF(obj);
         }
-        else {
-                PyErr_SetString(PyExc_NotImplementedError,"");
+    }
+    else if (o->ob_type->tp_as_number != NULL &&            \
+             o->ob_type->tp_as_number->nb_int != NULL) {
+        obj = o->ob_type->tp_as_number->nb_int(o);
+        if (obj != NULL) {
+            long_value = (longlong) PyLong_AsLongLong(obj);
+            Py_DECREF(obj);
         }
+    }
+    else {
+        PyErr_SetString(PyExc_NotImplementedError,"");
+    }
 
  finish:
-        if error_converting(long_value) {
-                PyErr_SetString(PyExc_TypeError, msg);
-                return -1;
+    if error_converting(long_value) {
+            PyErr_SetString(PyExc_TypeError, msg);
+            return -1;
         }
 
 #if (SIZEOF_LONGLONG > SIZEOF_INTP)
-        if ((long_value < MIN_INTP) || (long_value > MAX_INTP)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "integer won't fit into a C intp");
-                return -1;
-        }
+    if ((long_value < MIN_INTP) || (long_value > MAX_INTP)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "integer won't fit into a C intp");
+        return -1;
+    }
 #endif
-        return (intp) long_value;
+    return (intp) long_value;
 }
 
 
@@ -617,267 +616,267 @@ static PyObject *array_int(PyArrayObject *v);
 static int
 PyArray_PyIntAsInt(PyObject *o)
 {
-        long long_value = -1;
-        PyObject *obj;
-        static char *msg = "an integer is required";
-        PyObject *arr;
-        PyArray_Descr *descr;
-        int ret;
+    long long_value = -1;
+    PyObject *obj;
+    static char *msg = "an integer is required";
+    PyObject *arr;
+    PyArray_Descr *descr;
+    int ret;
 
 
-        if (!o) {
-                PyErr_SetString(PyExc_TypeError, msg);
-                return -1;
-        }
+    if (!o) {
+        PyErr_SetString(PyExc_TypeError, msg);
+        return -1;
+    }
 
-        if (PyInt_Check(o)) {
-                long_value = (long) PyInt_AS_LONG(o);
-                goto finish;
-        } else if (PyLong_Check(o)) {
-                long_value = (long) PyLong_AsLong(o);
-                goto finish;
-        }
+    if (PyInt_Check(o)) {
+        long_value = (long) PyInt_AS_LONG(o);
+        goto finish;
+    } else if (PyLong_Check(o)) {
+        long_value = (long) PyLong_AsLong(o);
+        goto finish;
+    }
 
-        descr = &INT_Descr;
-        arr=NULL;
-        if (PyArray_Check(o)) {
-                if (PyArray_SIZE(o)!=1 || !PyArray_ISINTEGER(o)) {
-                        PyErr_SetString(PyExc_TypeError, msg);
-                        return -1;
-                }
-                Py_INCREF(descr);
-                arr = PyArray_CastToType((PyArrayObject *)o, descr, 0);
-        }
-        if (PyArray_IsScalar(o, Integer)) {
-                Py_INCREF(descr);
-                arr = PyArray_FromScalar(o, descr);
-        }
-        if (arr != NULL) {
-                ret = *((int *)PyArray_DATA(arr));
-                Py_DECREF(arr);
-                return ret;
+    descr = &INT_Descr;
+    arr=NULL;
+    if (PyArray_Check(o)) {
+        if (PyArray_SIZE(o)!=1 || !PyArray_ISINTEGER(o)) {
+            PyErr_SetString(PyExc_TypeError, msg);
+            return -1;
         }
+        Py_INCREF(descr);
+        arr = PyArray_CastToType((PyArrayObject *)o, descr, 0);
+    }
+    if (PyArray_IsScalar(o, Integer)) {
+        Py_INCREF(descr);
+        arr = PyArray_FromScalar(o, descr);
+    }
+    if (arr != NULL) {
+        ret = *((int *)PyArray_DATA(arr));
+        Py_DECREF(arr);
+        return ret;
+    }
 #if (PY_VERSION_HEX >= 0x02050000)
-	if (PyIndex_Check(o)) {
-                PyObject* value = PyNumber_Index(o);
-		long_value = (longlong) PyInt_AsSsize_t(value);
-		goto finish;
-	}
+    if (PyIndex_Check(o)) {
+        PyObject* value = PyNumber_Index(o);
+        long_value = (longlong) PyInt_AsSsize_t(value);
+        goto finish;
+    }
 #endif
-        if (o->ob_type->tp_as_number != NULL &&         \
-            o->ob_type->tp_as_number->nb_int != NULL) {
-                obj = o->ob_type->tp_as_number->nb_int(o);
-                if (obj == NULL) return -1;
-                long_value = (long) PyLong_AsLong(obj);
-                Py_DECREF(obj);
-        }
-        else if (o->ob_type->tp_as_number != NULL &&                    \
-                 o->ob_type->tp_as_number->nb_long != NULL) {
-                obj = o->ob_type->tp_as_number->nb_long(o);
-                if (obj == NULL) return -1;
-                long_value = (long) PyLong_AsLong(obj);
-                Py_DECREF(obj);
-        }
-        else {
-                PyErr_SetString(PyExc_NotImplementedError,"");
-        }
+    if (o->ob_type->tp_as_number != NULL &&         \
+        o->ob_type->tp_as_number->nb_int != NULL) {
+        obj = o->ob_type->tp_as_number->nb_int(o);
+        if (obj == NULL) return -1;
+        long_value = (long) PyLong_AsLong(obj);
+        Py_DECREF(obj);
+    }
+    else if (o->ob_type->tp_as_number != NULL &&                    \
+             o->ob_type->tp_as_number->nb_long != NULL) {
+        obj = o->ob_type->tp_as_number->nb_long(o);
+        if (obj == NULL) return -1;
+        long_value = (long) PyLong_AsLong(obj);
+        Py_DECREF(obj);
+    }
+    else {
+        PyErr_SetString(PyExc_NotImplementedError,"");
+    }
 
  finish:
-        if error_converting(long_value) {
-                PyErr_SetString(PyExc_TypeError, msg);
-                return -1;
+    if error_converting(long_value) {
+            PyErr_SetString(PyExc_TypeError, msg);
+            return -1;
         }
 
 #if (SIZEOF_LONG > SIZEOF_INT)
-        if ((long_value < INT_MIN) || (long_value > INT_MAX)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "integer won't fit into a C int");
-                return -1;
-        }
+    if ((long_value < INT_MIN) || (long_value > INT_MAX)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "integer won't fit into a C int");
+        return -1;
+    }
 #endif
-        return (int) long_value;
+    return (int) long_value;
 }
 
 static char *
 index2ptr(PyArrayObject *mp, intp i)
 {
-        intp dim0;
-        if(mp->nd == 0) {
-                PyErr_SetString(PyExc_IndexError,
-                                "0-d arrays can't be indexed");
-                return NULL;
-        }
-        dim0 = mp->dimensions[0];
-        if (i<0) i += dim0;
-        if (i==0 && dim0 > 0)
-                return mp->data;
-
-        if (i>0 && i < dim0) {
-                return mp->data+i*mp->strides[0];
-        }
-        PyErr_SetString(PyExc_IndexError,"index out of bounds");
+    intp dim0;
+    if(mp->nd == 0) {
+        PyErr_SetString(PyExc_IndexError,
+                        "0-d arrays can't be indexed");
         return NULL;
+    }
+    dim0 = mp->dimensions[0];
+    if (i<0) i += dim0;
+    if (i==0 && dim0 > 0)
+        return mp->data;
+
+    if (i>0 && i < dim0) {
+        return mp->data+i*mp->strides[0];
+    }
+    PyErr_SetString(PyExc_IndexError,"index out of bounds");
+    return NULL;
 }
 
 /*OBJECT_API
- Compute the size of an array (in number of items)
+  Compute the size of an array (in number of items)
 */
 static intp
 PyArray_Size(PyObject *op)
 {
-        if (PyArray_Check(op)) {
-                return PyArray_SIZE((PyArrayObject *)op);
-        }
-        else {
-                return 0;
-        }
+    if (PyArray_Check(op)) {
+        return PyArray_SIZE((PyArrayObject *)op);
+    }
+    else {
+        return 0;
+    }
 }
 
 static int
 _copy_from0d(PyArrayObject *dest, PyArrayObject *src, int usecopy, int swap)
 {
-        char *aligned=NULL;
-        char *sptr;
-        int numcopies, nbytes;
-        void (*myfunc)(char *, intp, char *, intp, intp, int);
-        int retval=-1;
+    char *aligned=NULL;
+    char *sptr;
+    int numcopies, nbytes;
+    void (*myfunc)(char *, intp, char *, intp, intp, int);
+    int retval=-1;
 
-        NPY_BEGIN_THREADS_DEF
+    NPY_BEGIN_THREADS_DEF
 
         numcopies = PyArray_SIZE(dest);
-        if (numcopies < 1) return 0;
-        nbytes = PyArray_ITEMSIZE(src);
-
-        if (!PyArray_ISALIGNED(src)) {
-                aligned = malloc((size_t)nbytes);
-                if (aligned == NULL) {
-                        PyErr_NoMemory();
-                        return -1;
-                }
-                memcpy(aligned, src->data, (size_t) nbytes);
-                usecopy = 1;
-                sptr = aligned;
-        }
-        else sptr = src->data;
-        if (PyArray_ISALIGNED(dest)) {
-                myfunc = _strided_byte_copy;
-        }
-        else if (usecopy) {
-                myfunc = _unaligned_strided_byte_copy;
-        }
-        else {
-                myfunc = _unaligned_strided_byte_move;
-        }
+    if (numcopies < 1) return 0;
+    nbytes = PyArray_ITEMSIZE(src);
+
+    if (!PyArray_ISALIGNED(src)) {
+        aligned = malloc((size_t)nbytes);
+        if (aligned == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        memcpy(aligned, src->data, (size_t) nbytes);
+        usecopy = 1;
+        sptr = aligned;
+    }
+    else sptr = src->data;
+    if (PyArray_ISALIGNED(dest)) {
+        myfunc = _strided_byte_copy;
+    }
+    else if (usecopy) {
+        myfunc = _unaligned_strided_byte_copy;
+    }
+    else {
+        myfunc = _unaligned_strided_byte_move;
+    }
 
-        if ((dest->nd < 2) || PyArray_ISONESEGMENT(dest)) {
-                char *dptr;
-                intp dstride;
+    if ((dest->nd < 2) || PyArray_ISONESEGMENT(dest)) {
+        char *dptr;
+        intp dstride;
 
-                dptr = dest->data;
-                if (dest->nd == 1)
-                        dstride = dest->strides[0];
-                else
-                        dstride = nbytes;
+        dptr = dest->data;
+        if (dest->nd == 1)
+            dstride = dest->strides[0];
+        else
+            dstride = nbytes;
 
-                PyArray_INCREF(src);
-                PyArray_XDECREF(dest);
+        PyArray_INCREF(src);
+        PyArray_XDECREF(dest);
 
-                NPY_BEGIN_THREADS
+        NPY_BEGIN_THREADS
 
-                myfunc(dptr, dstride, sptr, 0, numcopies, (int) nbytes);
-                if (swap)
-                        _strided_byte_swap(dptr, dstride, numcopies, (int) nbytes);
+            myfunc(dptr, dstride, sptr, 0, numcopies, (int) nbytes);
+        if (swap)
+            _strided_byte_swap(dptr, dstride, numcopies, (int) nbytes);
 
-                NPY_END_THREADS
+        NPY_END_THREADS
 
-        }
-        else {
-                PyArrayIterObject *dit;
-                int axis=-1;
-                dit = (PyArrayIterObject *)\
-                        PyArray_IterAllButAxis((PyObject *)dest, &axis);
-                if (dit == NULL) goto finish;
-                PyArray_INCREF(src);
-                PyArray_XDECREF(dest);
-                NPY_BEGIN_THREADS
-                while(dit->index < dit->size) {
-                        myfunc(dit->dataptr, PyArray_STRIDE(dest, axis),
-                               sptr, 0,
-                               PyArray_DIM(dest, axis), nbytes);
-                        if (swap)
-                                _strided_byte_swap(dit->dataptr,
-                                                   PyArray_STRIDE(dest, axis),
-                                                   PyArray_DIM(dest, axis), nbytes);
-                        PyArray_ITER_NEXT(dit);
-                }
-                NPY_END_THREADS
-                Py_DECREF(dit);
-        }
-        retval = 0;
+            }
+    else {
+        PyArrayIterObject *dit;
+        int axis=-1;
+        dit = (PyArrayIterObject *)\
+            PyArray_IterAllButAxis((PyObject *)dest, &axis);
+        if (dit == NULL) goto finish;
+        PyArray_INCREF(src);
+        PyArray_XDECREF(dest);
+        NPY_BEGIN_THREADS
+            while(dit->index < dit->size) {
+                myfunc(dit->dataptr, PyArray_STRIDE(dest, axis),
+                       sptr, 0,
+                       PyArray_DIM(dest, axis), nbytes);
+                if (swap)
+                    _strided_byte_swap(dit->dataptr,
+                                       PyArray_STRIDE(dest, axis),
+                                       PyArray_DIM(dest, axis), nbytes);
+                PyArray_ITER_NEXT(dit);
+            }
+        NPY_END_THREADS
+            Py_DECREF(dit);
+    }
+    retval = 0;
  finish:
-        if (aligned != NULL) free(aligned);
-        return retval;
+    if (aligned != NULL) free(aligned);
+    return retval;
 }
 
 /* Special-case of PyArray_CopyInto when dst is 1-d
    and contiguous (and aligned).
    PyArray_CopyInto requires broadcastable arrays while
    this one is a flattening operation...
- */
+*/
 int _flat_copyinto(PyObject *dst, PyObject *src, NPY_ORDER order) {
-        PyArrayIterObject *it;
-        void (*myfunc)(char *, intp, char *, intp, intp, int);
-        char *dptr;
-        int axis;
-        int elsize;
-        intp nbytes;
-        NPY_BEGIN_THREADS_DEF
+    PyArrayIterObject *it;
+    void (*myfunc)(char *, intp, char *, intp, intp, int);
+    char *dptr;
+    int axis;
+    int elsize;
+    intp nbytes;
+    NPY_BEGIN_THREADS_DEF
 
 
         if (PyArray_NDIM(src) == 0) {
-                PyArray_INCREF((PyArrayObject *)src);
-                PyArray_XDECREF((PyArrayObject *)dst);
-                NPY_BEGIN_THREADS
+            PyArray_INCREF((PyArrayObject *)src);
+            PyArray_XDECREF((PyArrayObject *)dst);
+            NPY_BEGIN_THREADS
                 memcpy(PyArray_BYTES(dst), PyArray_BYTES(src),
                        PyArray_ITEMSIZE(src));
-                NPY_END_THREADS
+            NPY_END_THREADS
                 return 0;
         }
 
-        if (order == PyArray_FORTRANORDER) {
-                axis = 0;
-        }
-        else {
-                axis = PyArray_NDIM(src)-1;
-        }
+    if (order == PyArray_FORTRANORDER) {
+        axis = 0;
+    }
+    else {
+        axis = PyArray_NDIM(src)-1;
+    }
 
-        it = (PyArrayIterObject *)PyArray_IterAllButAxis(src, &axis);
-        if (it == NULL) return -1;
+    it = (PyArrayIterObject *)PyArray_IterAllButAxis(src, &axis);
+    if (it == NULL) return -1;
 
-        if (PyArray_ISALIGNED(src)) {
-                myfunc = _strided_byte_copy;
-        }
-        else {
-                myfunc = _unaligned_strided_byte_copy;
-        }
+    if (PyArray_ISALIGNED(src)) {
+        myfunc = _strided_byte_copy;
+    }
+    else {
+        myfunc = _unaligned_strided_byte_copy;
+    }
 
-        dptr = PyArray_BYTES(dst);
-        elsize = PyArray_ITEMSIZE(dst);
-        nbytes = elsize * PyArray_DIM(src, axis);
-        PyArray_INCREF((PyArrayObject *)src);
-        PyArray_XDECREF((PyArrayObject *)dst);
-        NPY_BEGIN_THREADS
+    dptr = PyArray_BYTES(dst);
+    elsize = PyArray_ITEMSIZE(dst);
+    nbytes = elsize * PyArray_DIM(src, axis);
+    PyArray_INCREF((PyArrayObject *)src);
+    PyArray_XDECREF((PyArrayObject *)dst);
+    NPY_BEGIN_THREADS
         while(it->index < it->size) {
-                myfunc(dptr, elsize, it->dataptr,
-                       PyArray_STRIDE(src,axis),
-                       PyArray_DIM(src,axis), elsize);
-                dptr += nbytes;
-                PyArray_ITER_NEXT(it);
+            myfunc(dptr, elsize, it->dataptr,
+                   PyArray_STRIDE(src,axis),
+                   PyArray_DIM(src,axis), elsize);
+            dptr += nbytes;
+            PyArray_ITER_NEXT(it);
         }
-        NPY_END_THREADS
+    NPY_END_THREADS
 
         Py_DECREF(it);
-        return 0;
+    return 0;
 }
 
 
@@ -886,48 +885,48 @@ _copy_from_same_shape(PyArrayObject *dest, PyArrayObject *src,
                       void (*myfunc)(char *, intp, char *, intp, intp, int),
                       int swap)
 {
-        int maxaxis=-1, elsize;
-        intp maxdim;
-        PyArrayIterObject *dit, *sit;
-        NPY_BEGIN_THREADS_DEF
+    int maxaxis=-1, elsize;
+    intp maxdim;
+    PyArrayIterObject *dit, *sit;
+    NPY_BEGIN_THREADS_DEF
 
         dit = (PyArrayIterObject *)                                     \
-                PyArray_IterAllButAxis((PyObject *)dest, &maxaxis);
-        sit = (PyArrayIterObject *)                                     \
-                PyArray_IterAllButAxis((PyObject *)src, &maxaxis);
+        PyArray_IterAllButAxis((PyObject *)dest, &maxaxis);
+    sit = (PyArrayIterObject *)                                     \
+        PyArray_IterAllButAxis((PyObject *)src, &maxaxis);
 
-        maxdim = dest->dimensions[maxaxis];
+    maxdim = dest->dimensions[maxaxis];
 
-        if ((dit == NULL) || (sit == NULL)) {
-                Py_XDECREF(dit);
-                Py_XDECREF(sit);
-                return -1;
-        }
-        elsize = PyArray_ITEMSIZE(dest);
+    if ((dit == NULL) || (sit == NULL)) {
+        Py_XDECREF(dit);
+        Py_XDECREF(sit);
+        return -1;
+    }
+    elsize = PyArray_ITEMSIZE(dest);
 
-        PyArray_INCREF(src);
-        PyArray_XDECREF(dest);
+    PyArray_INCREF(src);
+    PyArray_XDECREF(dest);
 
-        NPY_BEGIN_THREADS
+    NPY_BEGIN_THREADS
         while(dit->index < dit->size) {
-                /* strided copy of elsize bytes */
-                myfunc(dit->dataptr, dest->strides[maxaxis],
-                       sit->dataptr, src->strides[maxaxis],
-                       maxdim, elsize);
-                if (swap) {
-                        _strided_byte_swap(dit->dataptr,
-                                           dest->strides[maxaxis],
-                                           dest->dimensions[maxaxis],
-                                           elsize);
-                }
-                PyArray_ITER_NEXT(dit);
-                PyArray_ITER_NEXT(sit);
+            /* strided copy of elsize bytes */
+            myfunc(dit->dataptr, dest->strides[maxaxis],
+                   sit->dataptr, src->strides[maxaxis],
+                   maxdim, elsize);
+            if (swap) {
+                _strided_byte_swap(dit->dataptr,
+                                   dest->strides[maxaxis],
+                                   dest->dimensions[maxaxis],
+                                   elsize);
+            }
+            PyArray_ITER_NEXT(dit);
+            PyArray_ITER_NEXT(sit);
         }
-        NPY_END_THREADS
+    NPY_END_THREADS
 
         Py_DECREF(sit);
-        Py_DECREF(dit);
-        return 0;
+    Py_DECREF(dit);
+    return 0;
 }
 
 static int
@@ -935,57 +934,57 @@ _broadcast_copy(PyArrayObject *dest, PyArrayObject *src,
                 void (*myfunc)(char *, intp, char *, intp, intp, int),
                 int swap)
 {
-        int elsize;
-        PyArrayMultiIterObject *multi;
-        int maxaxis; intp maxdim;
-        NPY_BEGIN_THREADS_DEF
+    int elsize;
+    PyArrayMultiIterObject *multi;
+    int maxaxis; intp maxdim;
+    NPY_BEGIN_THREADS_DEF
 
         elsize = PyArray_ITEMSIZE(dest);
-        multi = (PyArrayMultiIterObject *)PyArray_MultiIterNew(2, dest, src);
-        if (multi == NULL) return -1;
-
-        if (multi->size != PyArray_SIZE(dest)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "array dimensions are not "\
-                                "compatible for copy");
-                Py_DECREF(multi);
-                return -1;
-        }
+    multi = (PyArrayMultiIterObject *)PyArray_MultiIterNew(2, dest, src);
+    if (multi == NULL) return -1;
 
-        maxaxis = PyArray_RemoveSmallest(multi);
-        if (maxaxis < 0) { /* copy 1 0-d array to another */
-                PyArray_INCREF(src);
-                PyArray_XDECREF(dest);
-                memcpy(dest->data, src->data, elsize);
-                if (swap) byte_swap_vector(dest->data, 1, elsize);
-                return 0;
-        }
-        maxdim = multi->dimensions[maxaxis];
+    if (multi->size != PyArray_SIZE(dest)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "array dimensions are not "\
+                        "compatible for copy");
+        Py_DECREF(multi);
+        return -1;
+    }
 
-        /* Increment the source and decrement the destination 
-           reference counts
-        */
+    maxaxis = PyArray_RemoveSmallest(multi);
+    if (maxaxis < 0) { /* copy 1 0-d array to another */
         PyArray_INCREF(src);
         PyArray_XDECREF(dest);
+        memcpy(dest->data, src->data, elsize);
+        if (swap) byte_swap_vector(dest->data, 1, elsize);
+        return 0;
+    }
+    maxdim = multi->dimensions[maxaxis];
 
-        NPY_BEGIN_THREADS
+    /* Increment the source and decrement the destination
+       reference counts
+    */
+    PyArray_INCREF(src);
+    PyArray_XDECREF(dest);
+
+    NPY_BEGIN_THREADS
         while(multi->index < multi->size) {
-                myfunc(multi->iters[0]->dataptr,
-                       multi->iters[0]->strides[maxaxis],
-                       multi->iters[1]->dataptr,
-                       multi->iters[1]->strides[maxaxis],
-                       maxdim, elsize);
-                if (swap) {
-                        _strided_byte_swap(multi->iters[0]->dataptr,
-                                           multi->iters[0]->strides[maxaxis],
-                                           maxdim, elsize);
-                }
-                PyArray_MultiIter_NEXT(multi);
+            myfunc(multi->iters[0]->dataptr,
+                   multi->iters[0]->strides[maxaxis],
+                   multi->iters[1]->dataptr,
+                   multi->iters[1]->strides[maxaxis],
+                   maxdim, elsize);
+            if (swap) {
+                _strided_byte_swap(multi->iters[0]->dataptr,
+                                   multi->iters[0]->strides[maxaxis],
+                                   maxdim, elsize);
+            }
+            PyArray_MultiIter_NEXT(multi);
         }
-        NPY_END_THREADS
+    NPY_END_THREADS
 
         Py_DECREF(multi);
-        return 0;
+    return 0;
 }
 
 /* If destination is not the right type, then src
@@ -1002,157 +1001,157 @@ _broadcast_copy(PyArrayObject *dest, PyArrayObject *src,
 static int
 _array_copy_into(PyArrayObject *dest, PyArrayObject *src, int usecopy)
 {
-        int swap;
-        void (*myfunc)(char *, intp, char *, intp, intp, int);
-        int simple;
-        int same;
-        NPY_BEGIN_THREADS_DEF
+    int swap;
+    void (*myfunc)(char *, intp, char *, intp, intp, int);
+    int simple;
+    int same;
+    NPY_BEGIN_THREADS_DEF
 
 
         if (!PyArray_EquivArrTypes(dest, src)) {
-                return PyArray_CastTo(dest, src);
+            return PyArray_CastTo(dest, src);
         }
 
-        if (!PyArray_ISWRITEABLE(dest)) {
-                PyErr_SetString(PyExc_RuntimeError,
-                                "cannot write to array");
-                return -1;
-        }
+    if (!PyArray_ISWRITEABLE(dest)) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "cannot write to array");
+        return -1;
+    }
 
-        same = PyArray_SAMESHAPE(dest, src);
-        simple = same && ((PyArray_ISCARRAY_RO(src) && PyArray_ISCARRAY(dest)) ||
-                          (PyArray_ISFARRAY_RO(src) && PyArray_ISFARRAY(dest)));
+    same = PyArray_SAMESHAPE(dest, src);
+    simple = same && ((PyArray_ISCARRAY_RO(src) && PyArray_ISCARRAY(dest)) ||
+                      (PyArray_ISFARRAY_RO(src) && PyArray_ISFARRAY(dest)));
 
-        if (simple) {
-                PyArray_INCREF(src);
-                PyArray_XDECREF(dest);
-                NPY_BEGIN_THREADS
-                if (usecopy)
-                        memcpy(dest->data, src->data, PyArray_NBYTES(dest));
-                else
-                        memmove(dest->data, src->data, PyArray_NBYTES(dest));
-                NPY_END_THREADS
-                return 0;
-        }
+    if (simple) {
+        PyArray_INCREF(src);
+        PyArray_XDECREF(dest);
+        NPY_BEGIN_THREADS
+            if (usecopy)
+                memcpy(dest->data, src->data, PyArray_NBYTES(dest));
+            else
+                memmove(dest->data, src->data, PyArray_NBYTES(dest));
+        NPY_END_THREADS
+            return 0;
+    }
 
-        swap = PyArray_ISNOTSWAPPED(dest) != PyArray_ISNOTSWAPPED(src);
+    swap = PyArray_ISNOTSWAPPED(dest) != PyArray_ISNOTSWAPPED(src);
 
-        if (src->nd == 0) {
-                return _copy_from0d(dest, src, usecopy, swap);
-        }
+    if (src->nd == 0) {
+        return _copy_from0d(dest, src, usecopy, swap);
+    }
 
-        if (PyArray_ISALIGNED(dest) && PyArray_ISALIGNED(src)) {
-                myfunc = _strided_byte_copy;
-        }
-        else if (usecopy) {
-                myfunc = _unaligned_strided_byte_copy;
-        }
-        else {
-                myfunc = _unaligned_strided_byte_move;
-        }
+    if (PyArray_ISALIGNED(dest) && PyArray_ISALIGNED(src)) {
+        myfunc = _strided_byte_copy;
+    }
+    else if (usecopy) {
+        myfunc = _unaligned_strided_byte_copy;
+    }
+    else {
+        myfunc = _unaligned_strided_byte_move;
+    }
 
-        /* Could combine these because _broadcasted_copy would work as well.
-           But, same-shape copying is so common we want to speed it up.
-        */
-        if (same) {
-                return _copy_from_same_shape(dest, src, myfunc, swap);
-        }
-        else {
-                return _broadcast_copy(dest, src, myfunc, swap);
-        }
+    /* Could combine these because _broadcasted_copy would work as well.
+       But, same-shape copying is so common we want to speed it up.
+    */
+    if (same) {
+        return _copy_from_same_shape(dest, src, myfunc, swap);
+    }
+    else {
+        return _broadcast_copy(dest, src, myfunc, swap);
+    }
 }
 
 /*OBJECT_API
- Copy an Array into another array -- memory must not overlap
- Does not require src and dest to have "broadcastable" shapes
- (only the same number of elements).
+  Copy an Array into another array -- memory must not overlap
+  Does not require src and dest to have "broadcastable" shapes
+  (only the same number of elements).
 */
 static int
 PyArray_CopyAnyInto(PyArrayObject *dest, PyArrayObject *src)
 {
-        int elsize, simple;
-        PyArrayIterObject *idest, *isrc;
-        void (*myfunc)(char *, intp, char *, intp, intp, int);
-        NPY_BEGIN_THREADS_DEF
+    int elsize, simple;
+    PyArrayIterObject *idest, *isrc;
+    void (*myfunc)(char *, intp, char *, intp, intp, int);
+    NPY_BEGIN_THREADS_DEF
 
         if (!PyArray_EquivArrTypes(dest, src)) {
-                return PyArray_CastAnyTo(dest, src);
-        }
-
-        if (!PyArray_ISWRITEABLE(dest)) {
-                PyErr_SetString(PyExc_RuntimeError,
-                                "cannot write to array");
-                return -1;
-        }
-
-        if (PyArray_SIZE(dest) != PyArray_SIZE(src)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "arrays must have the same number of elements"
-                                " for copy");
-                return -1;
+            return PyArray_CastAnyTo(dest, src);
         }
 
-        simple = ((PyArray_ISCARRAY_RO(src) && PyArray_ISCARRAY(dest)) ||
-                  (PyArray_ISFARRAY_RO(src) && PyArray_ISFARRAY(dest)));
+    if (!PyArray_ISWRITEABLE(dest)) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "cannot write to array");
+        return -1;
+    }
 
-        if (simple) {
-                PyArray_INCREF(src);
-                PyArray_XDECREF(dest);
-                NPY_BEGIN_THREADS
-                memcpy(dest->data, src->data, PyArray_NBYTES(dest));
-                NPY_END_THREADS
-                return 0;
-        }
+    if (PyArray_SIZE(dest) != PyArray_SIZE(src)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "arrays must have the same number of elements"
+                        " for copy");
+        return -1;
+    }
 
-        if (PyArray_SAMESHAPE(dest, src)) {
-                int swap;
-                if (PyArray_ISALIGNED(dest) && PyArray_ISALIGNED(src)) {
-                        myfunc = _strided_byte_copy;
-                }
-                else {
-                        myfunc = _unaligned_strided_byte_copy;
-                }
-                swap = PyArray_ISNOTSWAPPED(dest) != PyArray_ISNOTSWAPPED(src);
-                return _copy_from_same_shape(dest, src, myfunc, swap);
-        }
+    simple = ((PyArray_ISCARRAY_RO(src) && PyArray_ISCARRAY(dest)) ||
+              (PyArray_ISFARRAY_RO(src) && PyArray_ISFARRAY(dest)));
 
-        /* Otherwise we have to do an iterator-based copy */
-        idest = (PyArrayIterObject *)PyArray_IterNew((PyObject *)dest);
-        if (idest == NULL) return -1;
-        isrc = (PyArrayIterObject *)PyArray_IterNew((PyObject *)src);
-        if (isrc == NULL) {Py_DECREF(idest); return -1;}
-        elsize = dest->descr->elsize;
+    if (simple) {
         PyArray_INCREF(src);
         PyArray_XDECREF(dest);
         NPY_BEGIN_THREADS
+            memcpy(dest->data, src->data, PyArray_NBYTES(dest));
+        NPY_END_THREADS
+            return 0;
+    }
+
+    if (PyArray_SAMESHAPE(dest, src)) {
+        int swap;
+        if (PyArray_ISALIGNED(dest) && PyArray_ISALIGNED(src)) {
+            myfunc = _strided_byte_copy;
+        }
+        else {
+            myfunc = _unaligned_strided_byte_copy;
+        }
+        swap = PyArray_ISNOTSWAPPED(dest) != PyArray_ISNOTSWAPPED(src);
+        return _copy_from_same_shape(dest, src, myfunc, swap);
+    }
+
+    /* Otherwise we have to do an iterator-based copy */
+    idest = (PyArrayIterObject *)PyArray_IterNew((PyObject *)dest);
+    if (idest == NULL) return -1;
+    isrc = (PyArrayIterObject *)PyArray_IterNew((PyObject *)src);
+    if (isrc == NULL) {Py_DECREF(idest); return -1;}
+    elsize = dest->descr->elsize;
+    PyArray_INCREF(src);
+    PyArray_XDECREF(dest);
+    NPY_BEGIN_THREADS
         while(idest->index < idest->size) {
-                memcpy(idest->dataptr, isrc->dataptr, elsize);
-                PyArray_ITER_NEXT(idest);
-                PyArray_ITER_NEXT(isrc);
+            memcpy(idest->dataptr, isrc->dataptr, elsize);
+            PyArray_ITER_NEXT(idest);
+            PyArray_ITER_NEXT(isrc);
         }
-        NPY_END_THREADS
+    NPY_END_THREADS
         Py_DECREF(idest);
-        Py_DECREF(isrc);
-        return 0;
+    Py_DECREF(isrc);
+    return 0;
 }
 
 /*OBJECT_API
- Copy an Array into another array -- memory must not overlap.
+  Copy an Array into another array -- memory must not overlap.
 */
 static int
 PyArray_CopyInto(PyArrayObject *dest, PyArrayObject *src)
 {
-        return _array_copy_into(dest, src, 1);
+    return _array_copy_into(dest, src, 1);
 }
 
 
 /*OBJECT_API
- Move the memory of one array into another.
+  Move the memory of one array into another.
 */
 static int
 PyArray_MoveInto(PyArrayObject *dest, PyArrayObject *src)
 {
-        return _array_copy_into(dest, src, 0);
+    return _array_copy_into(dest, src, 0);
 }
 
 
@@ -1160,54 +1159,54 @@ PyArray_MoveInto(PyArrayObject *dest, PyArrayObject *src)
 static int
 PyArray_CopyObject(PyArrayObject *dest, PyObject *src_object)
 {
-        PyArrayObject *src;
-        PyObject *r;
-        int ret;
-
-        /* Special code to mimic Numeric behavior for
-           character arrays.
-        */
-        if (dest->descr->type == PyArray_CHARLTR && dest->nd > 0 \
-            && PyString_Check(src_object)) {
-                int n_new, n_old;
-                char *new_string;
-                PyObject *tmp;
-                n_new = dest->dimensions[dest->nd-1];
-                n_old = PyString_Size(src_object);
-                if (n_new > n_old) {
-                        new_string = (char *)malloc(n_new);
-                        memmove(new_string,
-                                PyString_AS_STRING(src_object),
-                                n_old);
-                        memset(new_string+n_old, ' ', n_new-n_old);
-                        tmp = PyString_FromStringAndSize(new_string, n_new);
-                        free(new_string);
-                        src_object = tmp;
-                }
+    PyArrayObject *src;
+    PyObject *r;
+    int ret;
+
+    /* Special code to mimic Numeric behavior for
+       character arrays.
+    */
+    if (dest->descr->type == PyArray_CHARLTR && dest->nd > 0 \
+        && PyString_Check(src_object)) {
+        int n_new, n_old;
+        char *new_string;
+        PyObject *tmp;
+        n_new = dest->dimensions[dest->nd-1];
+        n_old = PyString_Size(src_object);
+        if (n_new > n_old) {
+            new_string = (char *)malloc(n_new);
+            memmove(new_string,
+                    PyString_AS_STRING(src_object),
+                    n_old);
+            memset(new_string+n_old, ' ', n_new-n_old);
+            tmp = PyString_FromStringAndSize(new_string, n_new);
+            free(new_string);
+            src_object = tmp;
         }
+    }
 
-        if (PyArray_Check(src_object)) {
-                src = (PyArrayObject *)src_object;
-                Py_INCREF(src);
-        }
-        else if (!PyArray_IsScalar(src_object, Generic) && 
-                 PyArray_HasArrayInterface(src_object, r)) {
-                src = (PyArrayObject *)r;
-        }
-        else {
-                PyArray_Descr* dtype;
-                dtype = dest->descr;
-                Py_INCREF(dtype);
-                src = (PyArrayObject *)PyArray_FromAny(src_object, dtype, 0,
-                                                       dest->nd,
-                                                       FORTRAN_IF(dest), 
-                                                       NULL);
-        }
-        if (src == NULL) return -1;
-        
-        ret = PyArray_MoveInto(dest, src);
-        Py_DECREF(src);
-        return ret;
+    if (PyArray_Check(src_object)) {
+        src = (PyArrayObject *)src_object;
+        Py_INCREF(src);
+    }
+    else if (!PyArray_IsScalar(src_object, Generic) &&
+             PyArray_HasArrayInterface(src_object, r)) {
+        src = (PyArrayObject *)r;
+    }
+    else {
+        PyArray_Descr* dtype;
+        dtype = dest->descr;
+        Py_INCREF(dtype);
+        src = (PyArrayObject *)PyArray_FromAny(src_object, dtype, 0,
+                                               dest->nd,
+                                               FORTRAN_IF(dest),
+                                               NULL);
+    }
+    if (src == NULL) return -1;
+
+    ret = PyArray_MoveInto(dest, src);
+    Py_DECREF(src);
+    return ret;
 }
 
 
@@ -1217,228 +1216,228 @@ PyArray_CopyObject(PyArrayObject *dest, PyObject *src_object)
 
 /* steals reference to descr -- and enforces native byteorder on it.*/
 /*OBJECT_API
- Like FromDimsAndData but uses the Descr structure instead of typecode
- as input.
+  Like FromDimsAndData but uses the Descr structure instead of typecode
+  as input.
 */
 static PyObject *
 PyArray_FromDimsAndDataAndDescr(int nd, int *d,
                                 PyArray_Descr *descr,
                                 char *data)
 {
-        PyObject *ret;
+    PyObject *ret;
 #if SIZEOF_INTP != SIZEOF_INT
-        int i;
-        intp newd[MAX_DIMS];
+    int i;
+    intp newd[MAX_DIMS];
 #endif
 
-        if (!PyArray_ISNBO(descr->byteorder))
-                descr->byteorder = '=';
+    if (!PyArray_ISNBO(descr->byteorder))
+        descr->byteorder = '=';
 
 #if SIZEOF_INTP != SIZEOF_INT
-        for (i=0; i<nd; i++) newd[i] = (intp) d[i];
-        ret = PyArray_NewFromDescr(&PyArray_Type, descr,
-                                   nd, newd,
-                                   NULL, data,
-                                   (data ? CARRAY : 0), NULL);
+    for (i=0; i<nd; i++) newd[i] = (intp) d[i];
+    ret = PyArray_NewFromDescr(&PyArray_Type, descr,
+                               nd, newd,
+                               NULL, data,
+                               (data ? CARRAY : 0), NULL);
 #else
-        ret = PyArray_NewFromDescr(&PyArray_Type, descr,
-                                   nd, (intp *)d,
-                                   NULL, data,
-                                   (data ? CARRAY : 0), NULL);
+    ret = PyArray_NewFromDescr(&PyArray_Type, descr,
+                               nd, (intp *)d,
+                               NULL, data,
+                               (data ? CARRAY : 0), NULL);
 #endif
-        return ret;
+    return ret;
 }
 
 /*OBJECT_API
- Construct an empty array from dimensions and typenum
+  Construct an empty array from dimensions and typenum
 */
 static PyObject *
 PyArray_FromDims(int nd, int *d, int type)
 {
-        PyObject *ret;
-        ret = PyArray_FromDimsAndDataAndDescr(nd, d,
-                                              PyArray_DescrFromType(type),
-                                              NULL);
-        /* Old FromDims set memory to zero --- some algorithms
-           relied on that.  Better keep it the same. If
-           Object type, then it's already been set to zero, though.
-        */
-        if (ret && (PyArray_DESCR(ret)->type_num != PyArray_OBJECT)) {
-                memset(PyArray_DATA(ret), 0, PyArray_NBYTES(ret));
-        }
-        return ret;
+    PyObject *ret;
+    ret = PyArray_FromDimsAndDataAndDescr(nd, d,
+                                          PyArray_DescrFromType(type),
+                                          NULL);
+    /* Old FromDims set memory to zero --- some algorithms
+       relied on that.  Better keep it the same. If
+       Object type, then it's already been set to zero, though.
+    */
+    if (ret && (PyArray_DESCR(ret)->type_num != PyArray_OBJECT)) {
+        memset(PyArray_DATA(ret), 0, PyArray_NBYTES(ret));
+    }
+    return ret;
 }
 
 /* end old calls */
 
 
 /*OBJECT_API
- Copy an array.
+  Copy an array.
 */
 static PyObject *
 PyArray_NewCopy(PyArrayObject *m1, NPY_ORDER fortran)
 {
-        PyArrayObject *ret;
-        if (fortran == PyArray_ANYORDER)
-                fortran = PyArray_ISFORTRAN(m1);
-
-        Py_INCREF(m1->descr);
-        ret = (PyArrayObject *)PyArray_NewFromDescr(m1->ob_type,
-                                                    m1->descr,
-                                                    m1->nd,
-                                                    m1->dimensions,
-                                                    NULL, NULL,
-                                                    fortran,
-                                                    (PyObject *)m1);
-        if (ret == NULL) return NULL;
-        if (PyArray_CopyInto(ret, m1) == -1) {
-                Py_DECREF(ret);
-                return NULL;
-        }
+    PyArrayObject *ret;
+    if (fortran == PyArray_ANYORDER)
+        fortran = PyArray_ISFORTRAN(m1);
+
+    Py_INCREF(m1->descr);
+    ret = (PyArrayObject *)PyArray_NewFromDescr(m1->ob_type,
+                                                m1->descr,
+                                                m1->nd,
+                                                m1->dimensions,
+                                                NULL, NULL,
+                                                fortran,
+                                                (PyObject *)m1);
+    if (ret == NULL) return NULL;
+    if (PyArray_CopyInto(ret, m1) == -1) {
+        Py_DECREF(ret);
+        return NULL;
+    }
 
-        return (PyObject *)ret;
+    return (PyObject *)ret;
 }
 
 static PyObject *array_big_item(PyArrayObject *, intp);
 
 /* Does nothing with descr (cannot be NULL) */
 /*OBJECT_API
- Get scalar-equivalent to a region of memory described by a descriptor.
+  Get scalar-equivalent to a region of memory described by a descriptor.
 */
 static PyObject *
 PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
 {
-        PyTypeObject *type;
-        PyObject *obj;
-        void *destptr;
-        PyArray_CopySwapFunc *copyswap;
-        int type_num;
-        int itemsize;
-        int swap;
-
-        type_num = descr->type_num;
-        if (type_num == PyArray_BOOL)
-                PyArrayScalar_RETURN_BOOL_FROM_LONG(*(Bool*)data);
-        else if (PyDataType_FLAGCHK(descr, NPY_USE_GETITEM)) {
-                return descr->f->getitem(data, base);
-        }
-        itemsize = descr->elsize;
-        copyswap = descr->f->copyswap;
-        type = descr->typeobj;
-        swap = !PyArray_ISNBO(descr->byteorder);
-        if PyTypeNum_ISSTRING(type_num) { /* Eliminate NULL bytes */
-                char *dptr = data;
-                dptr += itemsize-1;
-                while(itemsize && *dptr-- == 0) itemsize--;
-                if (type_num == PyArray_UNICODE && itemsize) {
-                        /* make sure itemsize is a multiple of 4 */
-                        /* so round up to nearest multiple */
-                        itemsize = (((itemsize-1) >> 2) + 1) << 2;
-                }
+    PyTypeObject *type;
+    PyObject *obj;
+    void *destptr;
+    PyArray_CopySwapFunc *copyswap;
+    int type_num;
+    int itemsize;
+    int swap;
+
+    type_num = descr->type_num;
+    if (type_num == PyArray_BOOL)
+        PyArrayScalar_RETURN_BOOL_FROM_LONG(*(Bool*)data);
+    else if (PyDataType_FLAGCHK(descr, NPY_USE_GETITEM)) {
+        return descr->f->getitem(data, base);
+    }
+    itemsize = descr->elsize;
+    copyswap = descr->f->copyswap;
+    type = descr->typeobj;
+    swap = !PyArray_ISNBO(descr->byteorder);
+    if PyTypeNum_ISSTRING(type_num) { /* Eliminate NULL bytes */
+            char *dptr = data;
+            dptr += itemsize-1;
+            while(itemsize && *dptr-- == 0) itemsize--;
+            if (type_num == PyArray_UNICODE && itemsize) {
+                /* make sure itemsize is a multiple of 4 */
+                /* so round up to nearest multiple */
+                itemsize = (((itemsize-1) >> 2) + 1) << 2;
+            }
         }
-        if (type->tp_itemsize != 0)  /* String type */
-                obj = type->tp_alloc(type, itemsize);
-        else
-                obj = type->tp_alloc(type, 0);
-        if (obj == NULL) return NULL;
-        if PyTypeNum_ISFLEXIBLE(type_num) {
-                if (type_num == PyArray_STRING) {
-                        destptr = PyString_AS_STRING(obj);
-                        ((PyStringObject *)obj)->ob_shash = -1;
-                        ((PyStringObject *)obj)->ob_sstate =    \
-                                SSTATE_NOT_INTERNED;
-                        memcpy(destptr, data, itemsize);
-                        return obj;
-                }
-                else if (type_num == PyArray_UNICODE) {
-                        PyUnicodeObject *uni = (PyUnicodeObject*)obj;
-                        int length = itemsize >> 2;
+    if (type->tp_itemsize != 0)  /* String type */
+        obj = type->tp_alloc(type, itemsize);
+    else
+        obj = type->tp_alloc(type, 0);
+    if (obj == NULL) return NULL;
+    if PyTypeNum_ISFLEXIBLE(type_num) {
+            if (type_num == PyArray_STRING) {
+                destptr = PyString_AS_STRING(obj);
+                ((PyStringObject *)obj)->ob_shash = -1;
+                ((PyStringObject *)obj)->ob_sstate =    \
+                    SSTATE_NOT_INTERNED;
+                memcpy(destptr, data, itemsize);
+                return obj;
+            }
+            else if (type_num == PyArray_UNICODE) {
+                PyUnicodeObject *uni = (PyUnicodeObject*)obj;
+                int length = itemsize >> 2;
 #ifndef Py_UNICODE_WIDE
-                        char *buffer;
-                        int alloc=0;
-                        length *= 2;
+                char *buffer;
+                int alloc=0;
+                length *= 2;
 #endif
-                        /* Need an extra slot and need to use
-                           Python memory manager */
-                        uni->str = NULL;
-                        destptr = PyMem_NEW(Py_UNICODE,length+1);
-                        if (destptr == NULL) {
-                                Py_DECREF(obj);
-                                return PyErr_NoMemory();
-                        }
-                        uni->str = (Py_UNICODE *)destptr;
-                        uni->str[0] = 0;
-                        uni->str[length] = 0;
-                        uni->length = length;
-                        uni->hash = -1;
-                        uni->defenc = NULL;
+                /* Need an extra slot and need to use
+                   Python memory manager */
+                uni->str = NULL;
+                destptr = PyMem_NEW(Py_UNICODE,length+1);
+                if (destptr == NULL) {
+                    Py_DECREF(obj);
+                    return PyErr_NoMemory();
+                }
+                uni->str = (Py_UNICODE *)destptr;
+                uni->str[0] = 0;
+                uni->str[length] = 0;
+                uni->length = length;
+                uni->hash = -1;
+                uni->defenc = NULL;
 #ifdef Py_UNICODE_WIDE
-                        memcpy(destptr, data, itemsize);
-                        if (swap)
-                                byte_swap_vector(destptr, length, 4);
+                memcpy(destptr, data, itemsize);
+                if (swap)
+                    byte_swap_vector(destptr, length, 4);
 #else
-                        /* need aligned data buffer */
-                        if ((swap) || ((((intp)data) % descr->alignment) != 0)) {
-                                buffer = _pya_malloc(itemsize);
-                                if (buffer == NULL)
-                                        return PyErr_NoMemory();
-                                alloc = 1;
-                                memcpy(buffer, data, itemsize);
-                                if (swap) {
-                                        byte_swap_vector(buffer,
-                                                         itemsize >> 2, 4);
-                                }
-                        }
-                        else buffer = data;
-
-                        /* Allocated enough for 2-characters per itemsize.
-                           Now convert from the data-buffer
-                         */
-                        length = PyUCS2Buffer_FromUCS4(uni->str,
-                                                       (PyArray_UCS4 *)buffer,
-                                                       itemsize >> 2);
-                        if (alloc) _pya_free(buffer);
-                        /* Resize the unicode result */
-                        if (MyPyUnicode_Resize(uni, length) < 0) {
-                                Py_DECREF(obj);
-                                return NULL;
-                        }
+                /* need aligned data buffer */
+                if ((swap) || ((((intp)data) % descr->alignment) != 0)) {
+                    buffer = _pya_malloc(itemsize);
+                    if (buffer == NULL)
+                        return PyErr_NoMemory();
+                    alloc = 1;
+                    memcpy(buffer, data, itemsize);
+                    if (swap) {
+                        byte_swap_vector(buffer,
+                                         itemsize >> 2, 4);
+                    }
+                }
+                else buffer = data;
+
+                /* Allocated enough for 2-characters per itemsize.
+                   Now convert from the data-buffer
+                */
+                length = PyUCS2Buffer_FromUCS4(uni->str,
+                                               (PyArray_UCS4 *)buffer,
+                                               itemsize >> 2);
+                if (alloc) _pya_free(buffer);
+                /* Resize the unicode result */
+                if (MyPyUnicode_Resize(uni, length) < 0) {
+                    Py_DECREF(obj);
+                    return NULL;
+                }
 #endif
+                return obj;
+            }
+            else {
+                PyVoidScalarObject *vobj = (PyVoidScalarObject *)obj;
+                vobj->base = NULL;
+                vobj->descr = descr;
+                Py_INCREF(descr);
+                vobj->obval = NULL;
+                vobj->ob_size = itemsize;
+                vobj->flags = BEHAVED | OWNDATA;
+                swap = 0;
+                if (descr->names) {
+                    if (base) {
+                        Py_INCREF(base);
+                        vobj->base = base;
+                        vobj->flags = PyArray_FLAGS(base);
+                        vobj->flags &= ~OWNDATA;
+                        vobj->obval = data;
                         return obj;
+                    }
                 }
-                else {
-                        PyVoidScalarObject *vobj = (PyVoidScalarObject *)obj;
-                        vobj->base = NULL;
-                        vobj->descr = descr;
-                        Py_INCREF(descr);
-                        vobj->obval = NULL;
-                        vobj->ob_size = itemsize;
-                        vobj->flags = BEHAVED | OWNDATA;
-                        swap = 0;
-                        if (descr->names) {
-                                if (base) {
-                                        Py_INCREF(base);
-                                        vobj->base = base;
-                                        vobj->flags = PyArray_FLAGS(base);
-                                        vobj->flags &= ~OWNDATA;
-                                        vobj->obval = data;
-                                        return obj;
-                                }
-                        }
-                        destptr = PyDataMem_NEW(itemsize);
-                        if (destptr == NULL) {
-                                Py_DECREF(obj);
-                                return PyErr_NoMemory();
-                        }
-                        vobj->obval = destptr;
+                destptr = PyDataMem_NEW(itemsize);
+                if (destptr == NULL) {
+                    Py_DECREF(obj);
+                    return PyErr_NoMemory();
                 }
+                vobj->obval = destptr;
+            }
         }
-        else {
-                destptr = scalar_value(obj, descr);
-        }
-        /* copyswap for OBJECT increments the reference count */
-        copyswap(destptr, data, swap, base);
-        return obj;
+    else {
+        destptr = scalar_value(obj, descr);
+    }
+    /* copyswap for OBJECT increments the reference count */
+    copyswap(destptr, data, swap, base);
+    return obj;
 }
 
 /* returns an Array-Scalar Object of the type of arr
@@ -1455,31 +1454,31 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
 /* Return Array Scalar if 0-d array object is encountered */
 
 /*OBJECT_API
- Return either an array or the appropriate Python object if the array
- is 0d and matches a Python type.
+  Return either an array or the appropriate Python object if the array
+  is 0d and matches a Python type.
 */
 static PyObject *
 PyArray_Return(PyArrayObject *mp)
 {
 
-        if (mp == NULL) return NULL;
+    if (mp == NULL) return NULL;
 
-        if (PyErr_Occurred()) {
-                Py_XDECREF(mp);
-                return NULL;
-        }
+    if (PyErr_Occurred()) {
+        Py_XDECREF(mp);
+        return NULL;
+    }
 
-        if (!PyArray_Check(mp)) return (PyObject *)mp;
+    if (!PyArray_Check(mp)) return (PyObject *)mp;
 
-        if (mp->nd == 0) {
-                PyObject *ret;
-                ret = PyArray_ToScalar(mp->data, mp);
-                Py_DECREF(mp);
-                return ret;
-        }
-        else {
-                return (PyObject *)mp;
-        }
+    if (mp->nd == 0) {
+        PyObject *ret;
+        ret = PyArray_ToScalar(mp->data, mp);
+        Py_DECREF(mp);
+        return ret;
+    }
+    else {
+        return (PyObject *)mp;
+    }
 }
 
 
@@ -1489,41 +1488,41 @@ PyArray_Return(PyArrayObject *mp)
 static void
 PyArray_InitArrFuncs(PyArray_ArrFuncs *f)
 {
-        int i;
-        for (i=0; i<PyArray_NTYPES; i++) {
-                f->cast[i] = NULL;
-        }
-        f->getitem = NULL;
-        f->setitem = NULL;
-        f->copyswapn = NULL;
-        f->copyswap = NULL;
-        f->compare = NULL;
-        f->argmax = NULL;
-        f->dotfunc = NULL;
-        f->scanfunc = NULL;
-        f->fromstr = NULL;
-        f->nonzero = NULL;
-        f->fill = NULL;
-        f->fillwithscalar = NULL;
-        for (i=0; i<PyArray_NSORTS; i++) {
-                f->sort[i] = NULL;
-                f->argsort[i] = NULL;
-        }
-        f->castdict = NULL;
-        f->scalarkind = NULL;
-        f->cancastscalarkindto = NULL;
-        f->cancastto = NULL;
+    int i;
+    for (i=0; i<PyArray_NTYPES; i++) {
+        f->cast[i] = NULL;
+    }
+    f->getitem = NULL;
+    f->setitem = NULL;
+    f->copyswapn = NULL;
+    f->copyswap = NULL;
+    f->compare = NULL;
+    f->argmax = NULL;
+    f->dotfunc = NULL;
+    f->scanfunc = NULL;
+    f->fromstr = NULL;
+    f->nonzero = NULL;
+    f->fill = NULL;
+    f->fillwithscalar = NULL;
+    for (i=0; i<PyArray_NSORTS; i++) {
+        f->sort[i] = NULL;
+        f->argsort[i] = NULL;
+    }
+    f->castdict = NULL;
+    f->scalarkind = NULL;
+    f->cancastscalarkindto = NULL;
+    f->cancastto = NULL;
 }
 
 static Bool
 _default_nonzero(void *ip, void *arr)
 {
-        int elsize = PyArray_ITEMSIZE(arr);
-        char *ptr = ip;
-        while (elsize--) {
-                if (*ptr++ != 0) return TRUE;
-        }
-        return FALSE;
+    int elsize = PyArray_ITEMSIZE(arr);
+    char *ptr = ip;
+    while (elsize--) {
+        if (*ptr++ != 0) return TRUE;
+    }
+    return FALSE;
 }
 
 /*
@@ -1538,16 +1537,16 @@ _default_nonzero(void *ip, void *arr)
 static int
 PyArray_TypeNumFromName(char *str)
 {
-        int i;
-        PyArray_Descr *descr;
+    int i;
+    PyArray_Descr *descr;
 
-        for (i=0; i<NPY_NUMUSERTYPES; i++) {
-                descr = userdescrs[i];
-                if (strcmp(descr->typeobj->tp_name, str) == 0)
-                        return descr->type_num;
-        }
+    for (i=0; i<NPY_NUMUSERTYPES; i++) {
+        descr = userdescrs[i];
+        if (strcmp(descr->typeobj->tp_name, str) == 0)
+            return descr->type_num;
+    }
 
-        return PyArray_NOTYPE;
+    return PyArray_NOTYPE;
 }
 
 /*
@@ -1556,52 +1555,52 @@ PyArray_TypeNumFromName(char *str)
   defined in arraytypes.inc
 */
 /*MULTIARRAY_API
- Register Data type
- Does not change the reference count of descr
+  Register Data type
+  Does not change the reference count of descr
 */
 static int
 PyArray_RegisterDataType(PyArray_Descr *descr)
 {
-        PyArray_Descr *descr2;
-        int typenum;
-        int i;
-        PyArray_ArrFuncs *f;
-
-        /* See if this type is already registered */
-        for (i=0; i<NPY_NUMUSERTYPES; i++) {
-                descr2 = userdescrs[i];
-                if (descr2 == descr)
-                        return descr->type_num;
-        }
-        typenum = PyArray_USERDEF + NPY_NUMUSERTYPES;
-        descr->type_num = typenum;
-        if (descr->elsize == 0) {
-                PyErr_SetString(PyExc_ValueError, "cannot register a" \
-                                "flexible data-type");
-                return -1;
-        }
-        f = descr->f;
-        if (f->nonzero == NULL) {
-                f->nonzero = _default_nonzero;
-        }
-        if (f->copyswap == NULL || f->getitem == NULL ||
-            f->copyswapn == NULL || f->setitem == NULL) {
-                PyErr_SetString(PyExc_ValueError, "a required array function" \
-                                " is missing.");
-                return -1;
-        }
-        if (descr->typeobj == NULL) {
-                PyErr_SetString(PyExc_ValueError, "missing typeobject");
-                return -1;
-        }
-        userdescrs = realloc(userdescrs,
-                             (NPY_NUMUSERTYPES+1)*sizeof(void *));
-        if (userdescrs == NULL) {
-                PyErr_SetString(PyExc_MemoryError, "RegisterDataType");
-                return -1;
-        }
-        userdescrs[NPY_NUMUSERTYPES++] = descr;
-        return typenum;
+    PyArray_Descr *descr2;
+    int typenum;
+    int i;
+    PyArray_ArrFuncs *f;
+
+    /* See if this type is already registered */
+    for (i=0; i<NPY_NUMUSERTYPES; i++) {
+        descr2 = userdescrs[i];
+        if (descr2 == descr)
+            return descr->type_num;
+    }
+    typenum = PyArray_USERDEF + NPY_NUMUSERTYPES;
+    descr->type_num = typenum;
+    if (descr->elsize == 0) {
+        PyErr_SetString(PyExc_ValueError, "cannot register a" \
+                        "flexible data-type");
+        return -1;
+    }
+    f = descr->f;
+    if (f->nonzero == NULL) {
+        f->nonzero = _default_nonzero;
+    }
+    if (f->copyswap == NULL || f->getitem == NULL ||
+        f->copyswapn == NULL || f->setitem == NULL) {
+        PyErr_SetString(PyExc_ValueError, "a required array function" \
+                        " is missing.");
+        return -1;
+    }
+    if (descr->typeobj == NULL) {
+        PyErr_SetString(PyExc_ValueError, "missing typeobject");
+        return -1;
+    }
+    userdescrs = realloc(userdescrs,
+                         (NPY_NUMUSERTYPES+1)*sizeof(void *));
+    if (userdescrs == NULL) {
+        PyErr_SetString(PyExc_MemoryError, "RegisterDataType");
+        return -1;
+    }
+    userdescrs[NPY_NUMUSERTYPES++] = descr;
+    return typenum;
 }
 
 /*MULTIARRAY_API
@@ -1612,41 +1611,41 @@ static int
 PyArray_RegisterCastFunc(PyArray_Descr *descr, int totype,
                          PyArray_VectorUnaryFunc *castfunc)
 {
-        PyObject *cobj, *key;
-        int ret;
-        if (totype < PyArray_NTYPES) {
-                descr->f->cast[totype] = castfunc;
-                return 0;
-        }
-        if (!PyTypeNum_ISUSERDEF(totype)) {
-                PyErr_SetString(PyExc_TypeError, "invalid type number.");
-                return -1;
-        }
-        if (descr->f->castdict == NULL) {
-                descr->f->castdict = PyDict_New();
-                if (descr->f->castdict == NULL) return -1;
-        }
-        key = PyInt_FromLong(totype);
-        if (PyErr_Occurred()) return -1;
-        cobj = PyCObject_FromVoidPtr((void *)castfunc, NULL);
-        if (cobj == NULL) {Py_DECREF(key); return -1;}
-        ret = PyDict_SetItem(descr->f->castdict, key, cobj);
-        Py_DECREF(key);
-        Py_DECREF(cobj);
-        return ret;
+    PyObject *cobj, *key;
+    int ret;
+    if (totype < PyArray_NTYPES) {
+        descr->f->cast[totype] = castfunc;
+        return 0;
+    }
+    if (!PyTypeNum_ISUSERDEF(totype)) {
+        PyErr_SetString(PyExc_TypeError, "invalid type number.");
+        return -1;
+    }
+    if (descr->f->castdict == NULL) {
+        descr->f->castdict = PyDict_New();
+        if (descr->f->castdict == NULL) return -1;
+    }
+    key = PyInt_FromLong(totype);
+    if (PyErr_Occurred()) return -1;
+    cobj = PyCObject_FromVoidPtr((void *)castfunc, NULL);
+    if (cobj == NULL) {Py_DECREF(key); return -1;}
+    ret = PyDict_SetItem(descr->f->castdict, key, cobj);
+    Py_DECREF(key);
+    Py_DECREF(cobj);
+    return ret;
 }
 
 static int *
 _append_new(int *types, int insert)
 {
-        int n=0;
-        int *newtypes;
+    int n=0;
+    int *newtypes;
 
-        while (types[n] != PyArray_NOTYPE) n++;
-        newtypes = (int *)realloc(types, (n+2)*sizeof(int));
-        newtypes[n] = insert;
-        newtypes[n+1] = PyArray_NOTYPE;
-        return newtypes;
+    while (types[n] != PyArray_NOTYPE) n++;
+    newtypes = (int *)realloc(types, (n+2)*sizeof(int));
+    newtypes[n] = insert;
+    newtypes[n+1] = PyArray_NOTYPE;
+    return newtypes;
 }
 
 /*MULTIARRAY_API
@@ -1657,244 +1656,244 @@ static int
 PyArray_RegisterCanCast(PyArray_Descr *descr, int totype,
                         NPY_SCALARKIND scalar)
 {
-        if (scalar == PyArray_NOSCALAR) {
-                /* register with cancastto */
-                /* These lists won't be freed once created
-                   -- they become part of the data-type */
-                if (descr->f->cancastto == NULL) {
-                        descr->f->cancastto = (int *)malloc(1*sizeof(int));
-                        descr->f->cancastto[0] = PyArray_NOTYPE;
-                }
-                descr->f->cancastto = _append_new(descr->f->cancastto,
-                                                  totype);
+    if (scalar == PyArray_NOSCALAR) {
+        /* register with cancastto */
+        /* These lists won't be freed once created
+           -- they become part of the data-type */
+        if (descr->f->cancastto == NULL) {
+            descr->f->cancastto = (int *)malloc(1*sizeof(int));
+            descr->f->cancastto[0] = PyArray_NOTYPE;
         }
-        else {
-                /* register with cancastscalarkindto */
-                if (descr->f->cancastscalarkindto == NULL) {
-                        int i;
-                        descr->f->cancastscalarkindto =                 \
-                                (int **)malloc(PyArray_NSCALARKINDS*    \
-                                               sizeof(int*));
-                        for (i=0; i<PyArray_NSCALARKINDS; i++) {
-                                descr->f->cancastscalarkindto[i] = NULL;
-                        }
-                }
-                if (descr->f->cancastscalarkindto[scalar] == NULL) {
-                        descr->f->cancastscalarkindto[scalar] = \
-                                (int *)malloc(1*sizeof(int));
-                        descr->f->cancastscalarkindto[scalar][0] =      \
-                                PyArray_NOTYPE;
-                }
-                descr->f->cancastscalarkindto[scalar] =                 \
-                        _append_new(descr->f->cancastscalarkindto[scalar],
-                                    totype);
+        descr->f->cancastto = _append_new(descr->f->cancastto,
+                                          totype);
+    }
+    else {
+        /* register with cancastscalarkindto */
+        if (descr->f->cancastscalarkindto == NULL) {
+            int i;
+            descr->f->cancastscalarkindto =                 \
+                (int **)malloc(PyArray_NSCALARKINDS*    \
+                               sizeof(int*));
+            for (i=0; i<PyArray_NSCALARKINDS; i++) {
+                descr->f->cancastscalarkindto[i] = NULL;
+            }
         }
-        return 0;
+        if (descr->f->cancastscalarkindto[scalar] == NULL) {
+            descr->f->cancastscalarkindto[scalar] = \
+                (int *)malloc(1*sizeof(int));
+            descr->f->cancastscalarkindto[scalar][0] =      \
+                PyArray_NOTYPE;
+        }
+        descr->f->cancastscalarkindto[scalar] =                 \
+            _append_new(descr->f->cancastscalarkindto[scalar],
+                        totype);
+    }
+    return 0;
 }
 
 /*OBJECT_API
- To File
+  To File
 */
 static int
 PyArray_ToFile(PyArrayObject *self, FILE *fp, char *sep, char *format)
 {
-        intp size;
-        intp n, n2;
-        size_t n3, n4;
-        PyArrayIterObject *it;
-        PyObject *obj, *strobj, *tupobj;
-
-        n3 = (sep ? strlen((const char *)sep) : 0);
-        if (n3 == 0) { /* binary data */
-                if (PyDataType_FLAGCHK(self->descr, NPY_LIST_PICKLE)) {
-                        PyErr_SetString(PyExc_ValueError, "cannot write " \
-                                        "object arrays to a file in "   \
-                                        "binary mode");
-                        return -1;
+    intp size;
+    intp n, n2;
+    size_t n3, n4;
+    PyArrayIterObject *it;
+    PyObject *obj, *strobj, *tupobj;
+
+    n3 = (sep ? strlen((const char *)sep) : 0);
+    if (n3 == 0) { /* binary data */
+        if (PyDataType_FLAGCHK(self->descr, NPY_LIST_PICKLE)) {
+            PyErr_SetString(PyExc_ValueError, "cannot write " \
+                            "object arrays to a file in "   \
+                            "binary mode");
+            return -1;
+        }
+
+        if (PyArray_ISCONTIGUOUS(self)) {
+            size = PyArray_SIZE(self);
+            NPY_BEGIN_ALLOW_THREADS
+                n=fwrite((const void *)self->data,
+                         (size_t) self->descr->elsize,
+                         (size_t) size, fp);
+            NPY_END_ALLOW_THREADS
+                if (n < size) {
+                    PyErr_Format(PyExc_ValueError,
+                                 "%ld requested and %ld written",
+                                 (long) size, (long) n);
+                    return -1;
                 }
+        }
+        else {
+            NPY_BEGIN_THREADS_DEF
 
-                if (PyArray_ISCONTIGUOUS(self)) {
-                        size = PyArray_SIZE(self);
-                        NPY_BEGIN_ALLOW_THREADS
-                        n=fwrite((const void *)self->data,
-                                 (size_t) self->descr->elsize,
-                                 (size_t) size, fp);
-                        NPY_END_ALLOW_THREADS
-                        if (n < size) {
-                                PyErr_Format(PyExc_ValueError,
-                                             "%ld requested and %ld written",
-                                             (long) size, (long) n);
-                                return -1;
-                        }
-                }
-                else {
-                        NPY_BEGIN_THREADS_DEF
-
-                        it=(PyArrayIterObject *)                        \
-                                PyArray_IterNew((PyObject *)self);
-                        NPY_BEGIN_THREADS
-                        while(it->index < it->size) {
-                                if (fwrite((const void *)it->dataptr,
-                                           (size_t) self->descr->elsize,
-                                           1, fp) < 1) {
-                                        NPY_END_THREADS
-                                        PyErr_Format(PyExc_IOError,
-                                                     "problem writing element"\
-                                                     " %d to file",
-                                                     (int)it->index);
-                                        Py_DECREF(it);
-                                        return -1;
-                                }
-                                PyArray_ITER_NEXT(it);
-                        }
+                it=(PyArrayIterObject *)                        \
+                PyArray_IterNew((PyObject *)self);
+            NPY_BEGIN_THREADS
+                while(it->index < it->size) {
+                    if (fwrite((const void *)it->dataptr,
+                               (size_t) self->descr->elsize,
+                               1, fp) < 1) {
                         NPY_END_THREADS
+                            PyErr_Format(PyExc_IOError,
+                                         "problem writing element"\
+                                         " %d to file",
+                                         (int)it->index);
                         Py_DECREF(it);
+                        return -1;
+                    }
+                    PyArray_ITER_NEXT(it);
                 }
+            NPY_END_THREADS
+                Py_DECREF(it);
         }
-        else {  /* text data */
+    }
+    else {  /* text data */
 
-                it=(PyArrayIterObject *)                                \
-                        PyArray_IterNew((PyObject *)self);
-                n4 = (format ? strlen((const char *)format) : 0);
-                while(it->index < it->size) {
-                        obj = self->descr->f->getitem(it->dataptr, self);
-                        if (obj == NULL) {Py_DECREF(it); return -1;}
-                        if (n4 == 0) { /* standard writing */
-                                strobj = PyObject_Str(obj);
-                                Py_DECREF(obj);
-                                if (strobj == NULL) {Py_DECREF(it); return -1;}
-                        }
-                        else { /* use format string */
-                                tupobj = PyTuple_New(1);
-                                if (tupobj == NULL) {Py_DECREF(it); return -1;}
-                                PyTuple_SET_ITEM(tupobj,0,obj);
-                                obj = PyString_FromString((const char *)format);
-                                if (obj == NULL) {Py_DECREF(tupobj);
-                                        Py_DECREF(it); return -1;}
-                                strobj = PyString_Format(obj, tupobj);
-                                Py_DECREF(obj);
-                                Py_DECREF(tupobj);
-                                if (strobj == NULL) {Py_DECREF(it); return -1;}
-                        }
-                        NPY_BEGIN_ALLOW_THREADS
-                        n=fwrite(PyString_AS_STRING(strobj), 1,
-                                 n2=PyString_GET_SIZE(strobj), fp);
-                        NPY_END_ALLOW_THREADS
-                        if (n < n2) {
-                                PyErr_Format(PyExc_IOError,
-                                             "problem writing element %d"\
-                                             " to file",
-                                             (int) it->index);
-                                Py_DECREF(strobj);
-                                Py_DECREF(it);
-                                return -1;
-                        }
-                        /* write separator for all but last one */
-                        if (it->index != it->size-1)
-                                if (fwrite(sep, 1, n3, fp) < n3) {
-                                        PyErr_Format(PyExc_IOError,
-                                                     "problem writing "\
-                                                     "separator to file");
-                                        Py_DECREF(strobj);
-                                        Py_DECREF(it);
-                                        return -1;
-                                }
-                        Py_DECREF(strobj);
-                        PyArray_ITER_NEXT(it);
-                }
-                Py_DECREF(it);
+        it=(PyArrayIterObject *)                                \
+            PyArray_IterNew((PyObject *)self);
+        n4 = (format ? strlen((const char *)format) : 0);
+        while(it->index < it->size) {
+            obj = self->descr->f->getitem(it->dataptr, self);
+            if (obj == NULL) {Py_DECREF(it); return -1;}
+            if (n4 == 0) { /* standard writing */
+                strobj = PyObject_Str(obj);
+                Py_DECREF(obj);
+                if (strobj == NULL) {Py_DECREF(it); return -1;}
+            }
+            else { /* use format string */
+                tupobj = PyTuple_New(1);
+                if (tupobj == NULL) {Py_DECREF(it); return -1;}
+                PyTuple_SET_ITEM(tupobj,0,obj);
+                obj = PyString_FromString((const char *)format);
+                if (obj == NULL) {Py_DECREF(tupobj);
+                    Py_DECREF(it); return -1;}
+                strobj = PyString_Format(obj, tupobj);
+                Py_DECREF(obj);
+                Py_DECREF(tupobj);
+                if (strobj == NULL) {Py_DECREF(it); return -1;}
+            }
+            NPY_BEGIN_ALLOW_THREADS
+                n=fwrite(PyString_AS_STRING(strobj), 1,
+                         n2=PyString_GET_SIZE(strobj), fp);
+            NPY_END_ALLOW_THREADS
+                if (n < n2) {
+                    PyErr_Format(PyExc_IOError,
+                                 "problem writing element %d"\
+                                 " to file",
+                                 (int) it->index);
+                    Py_DECREF(strobj);
+                    Py_DECREF(it);
+                    return -1;
+                }
+            /* write separator for all but last one */
+            if (it->index != it->size-1)
+                if (fwrite(sep, 1, n3, fp) < n3) {
+                    PyErr_Format(PyExc_IOError,
+                                 "problem writing "\
+                                 "separator to file");
+                    Py_DECREF(strobj);
+                    Py_DECREF(it);
+                    return -1;
+                }
+            Py_DECREF(strobj);
+            PyArray_ITER_NEXT(it);
         }
-        return 0;
+        Py_DECREF(it);
+    }
+    return 0;
 }
 
 /*OBJECT_API
- To List
+  To List
 */
 static PyObject *
 PyArray_ToList(PyArrayObject *self)
 {
-        PyObject *lp;
-        PyArrayObject *v;
-        intp sz, i;
+    PyObject *lp;
+    PyArrayObject *v;
+    intp sz, i;
 
-        if (!PyArray_Check(self)) return (PyObject *)self;
+    if (!PyArray_Check(self)) return (PyObject *)self;
 
-        if (self->nd == 0)
-                return self->descr->f->getitem(self->data,self);
+    if (self->nd == 0)
+        return self->descr->f->getitem(self->data,self);
 
-        sz = self->dimensions[0];
-        lp = PyList_New(sz);
+    sz = self->dimensions[0];
+    lp = PyList_New(sz);
 
-        for (i=0; i<sz; i++) {
-                v=(PyArrayObject *)array_big_item(self, i);
-                if (v->nd >= self->nd) {
-                        PyErr_SetString(PyExc_RuntimeError,
-                                        "array_item not returning smaller-" \
-                                        "dimensional array");
-                        Py_DECREF(v);
-                        Py_DECREF(lp);
-                        return NULL;
-                }
-                PyList_SetItem(lp, i, PyArray_ToList(v));
-                Py_DECREF(v);
+    for (i=0; i<sz; i++) {
+        v=(PyArrayObject *)array_big_item(self, i);
+        if (v->nd >= self->nd) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "array_item not returning smaller-" \
+                            "dimensional array");
+            Py_DECREF(v);
+            Py_DECREF(lp);
+            return NULL;
         }
+        PyList_SetItem(lp, i, PyArray_ToList(v));
+        Py_DECREF(v);
+    }
 
-        return lp;
+    return lp;
 }
 
 /*OBJECT_API*/
 static PyObject *
 PyArray_ToString(PyArrayObject *self, NPY_ORDER order)
 {
-        intp numbytes;
-        intp index;
-        char *dptr;
-        int elsize;
-        PyObject *ret;
-        PyArrayIterObject *it;
-
-        if (order == NPY_ANYORDER)
-                order = PyArray_ISFORTRAN(self);
-
-        /*        if (PyArray_TYPE(self) == PyArray_OBJECT) {
-                  PyErr_SetString(PyExc_ValueError, "a string for the data" \
-                  "in an object array is not appropriate");
-                  return NULL;
-                  }
-        */
-
-        numbytes = PyArray_NBYTES(self);
-        if ((PyArray_ISCONTIGUOUS(self) && (order == NPY_CORDER)) ||    \
-            (PyArray_ISFORTRAN(self) && (order == NPY_FORTRANORDER))) {
-                ret = PyString_FromStringAndSize(self->data, (int) numbytes);
+    intp numbytes;
+    intp index;
+    char *dptr;
+    int elsize;
+    PyObject *ret;
+    PyArrayIterObject *it;
+
+    if (order == NPY_ANYORDER)
+        order = PyArray_ISFORTRAN(self);
+
+    /*        if (PyArray_TYPE(self) == PyArray_OBJECT) {
+              PyErr_SetString(PyExc_ValueError, "a string for the data" \
+              "in an object array is not appropriate");
+              return NULL;
+              }
+    */
+
+    numbytes = PyArray_NBYTES(self);
+    if ((PyArray_ISCONTIGUOUS(self) && (order == NPY_CORDER)) ||    \
+        (PyArray_ISFORTRAN(self) && (order == NPY_FORTRANORDER))) {
+        ret = PyString_FromStringAndSize(self->data, (int) numbytes);
+    }
+    else {
+        PyObject *new;
+        if (order == NPY_FORTRANORDER) {
+            /* iterators are always in C-order */
+            new = PyArray_Transpose(self, NULL);
+            if (new == NULL) return NULL;
         }
         else {
-                PyObject *new;
-                if (order == NPY_FORTRANORDER) {
-                        /* iterators are always in C-order */
-                        new = PyArray_Transpose(self, NULL);
-                        if (new == NULL) return NULL;
-                }
-                else {
-                        Py_INCREF(self);
-                        new = (PyObject *)self;
-                }
-                it = (PyArrayIterObject *)PyArray_IterNew(new);
-                Py_DECREF(new);
-                if (it==NULL) return NULL;
-                ret = PyString_FromStringAndSize(NULL, (int) numbytes);
-                if (ret == NULL) {Py_DECREF(it); return NULL;}
-                dptr = PyString_AS_STRING(ret);
-                index = it->size;
-                elsize = self->descr->elsize;
-                while(index--) {
-                        memcpy(dptr, it->dataptr, elsize);
-                        dptr += elsize;
-                        PyArray_ITER_NEXT(it);
-                }
-                Py_DECREF(it);
+            Py_INCREF(self);
+            new = (PyObject *)self;
         }
-        return ret;
+        it = (PyArrayIterObject *)PyArray_IterNew(new);
+        Py_DECREF(new);
+        if (it==NULL) return NULL;
+        ret = PyString_FromStringAndSize(NULL, (int) numbytes);
+        if (ret == NULL) {Py_DECREF(it); return NULL;}
+        dptr = PyString_AS_STRING(ret);
+        index = it->size;
+        elsize = self->descr->elsize;
+        while(index--) {
+            memcpy(dptr, it->dataptr, elsize);
+            dptr += elsize;
+            PyArray_ITER_NEXT(it);
+        }
+        Py_DECREF(it);
+    }
+    return ret;
 }
 
 
@@ -1906,49 +1905,49 @@ PyArray_ToString(PyArrayObject *self, NPY_ORDER order)
 static void
 array_dealloc(PyArrayObject *self) {
 
-        if (self->weakreflist != NULL)
-                PyObject_ClearWeakRefs((PyObject *)self);
+    if (self->weakreflist != NULL)
+        PyObject_ClearWeakRefs((PyObject *)self);
 
-        if(self->base) {
-                /* UPDATEIFCOPY means that base points to an
-                   array that should be updated with the contents
-                   of this array upon destruction.
-                   self->base->flags must have been WRITEABLE
-                   (checked previously) and it was locked here
-                   thus, unlock it.
-                */
-                if (self->flags & UPDATEIFCOPY) {
-                        ((PyArrayObject *)self->base)->flags |= WRITEABLE;
-                        Py_INCREF(self); /* hold on to self in next call */
-                        if (PyArray_CopyAnyInto((PyArrayObject *)self->base,
-                                                self) < 0) {
-                                PyErr_Print();
-                                PyErr_Clear();
-                        }
-                        /* Don't need to DECREF -- because we are deleting
-                           self already... */
-                }
-                /* In any case base is pointing to something that we need
-                   to DECREF -- either a view or a buffer object */
-                Py_DECREF(self->base);
-        }
-
-        if ((self->flags & OWNDATA) && self->data) {
-                /* Free internal references if an Object array */
-                if (PyDataType_FLAGCHK(self->descr, NPY_ITEM_REFCOUNT)) {
-                        Py_INCREF(self); /*hold on to self */
-                        PyArray_XDECREF(self);
-                        /* Don't need to DECREF -- because we are deleting
-                           self already... */
-                }
-                PyDataMem_FREE(self->data);
+    if(self->base) {
+        /* UPDATEIFCOPY means that base points to an
+           array that should be updated with the contents
+           of this array upon destruction.
+           self->base->flags must have been WRITEABLE
+           (checked previously) and it was locked here
+           thus, unlock it.
+        */
+        if (self->flags & UPDATEIFCOPY) {
+            ((PyArrayObject *)self->base)->flags |= WRITEABLE;
+            Py_INCREF(self); /* hold on to self in next call */
+            if (PyArray_CopyAnyInto((PyArrayObject *)self->base,
+                                    self) < 0) {
+                PyErr_Print();
+                PyErr_Clear();
+            }
+            /* Don't need to DECREF -- because we are deleting
+               self already... */
+        }
+        /* In any case base is pointing to something that we need
+           to DECREF -- either a view or a buffer object */
+        Py_DECREF(self->base);
+    }
+
+    if ((self->flags & OWNDATA) && self->data) {
+        /* Free internal references if an Object array */
+        if (PyDataType_FLAGCHK(self->descr, NPY_ITEM_REFCOUNT)) {
+            Py_INCREF(self); /*hold on to self */
+            PyArray_XDECREF(self);
+            /* Don't need to DECREF -- because we are deleting
+               self already... */
         }
+        PyDataMem_FREE(self->data);
+    }
 
-        PyDimMem_FREE(self->dimensions);
+    PyDimMem_FREE(self->dimensions);
 
-        Py_DECREF(self->descr);
+    Py_DECREF(self->descr);
 
-        self->ob_type->tp_free((PyObject *)self);
+    self->ob_type->tp_free((PyObject *)self);
 }
 
 /*************************************************************************
@@ -1958,108 +1957,108 @@ array_dealloc(PyArrayObject *self) {
 static Py_ssize_t
 array_length(PyArrayObject *self)
 {
-        if (self->nd != 0) {
-                return self->dimensions[0];
-        } else {
-                PyErr_SetString(PyExc_TypeError, "len() of unsized object");
-                return -1;
-        }
+    if (self->nd != 0) {
+        return self->dimensions[0];
+    } else {
+        PyErr_SetString(PyExc_TypeError, "len() of unsized object");
+        return -1;
+    }
 }
 
 static PyObject *
 array_big_item(PyArrayObject *self, intp i)
 {
-        char *item;
-        PyArrayObject *r;
-
-        if(self->nd == 0) {
-                PyErr_SetString(PyExc_IndexError,
-                                "0-d arrays can't be indexed");
-                return NULL;
-        }
-        if ((item = index2ptr(self, i)) == NULL) return NULL;
+    char *item;
+    PyArrayObject *r;
 
-        Py_INCREF(self->descr);
-        r = (PyArrayObject *)PyArray_NewFromDescr(self->ob_type,
-                                                  self->descr,
-                                                  self->nd-1,
-                                                  self->dimensions+1,
-                                                  self->strides+1, item,
-                                                  self->flags,
-                                                  (PyObject *)self);
-        if (r == NULL) return NULL;
-        Py_INCREF(self);
-        r->base = (PyObject *)self;
-        PyArray_UpdateFlags(r, CONTIGUOUS | FORTRAN);
-        return (PyObject *)r;
+    if(self->nd == 0) {
+        PyErr_SetString(PyExc_IndexError,
+                        "0-d arrays can't be indexed");
+        return NULL;
+    }
+    if ((item = index2ptr(self, i)) == NULL) return NULL;
+
+    Py_INCREF(self->descr);
+    r = (PyArrayObject *)PyArray_NewFromDescr(self->ob_type,
+                                              self->descr,
+                                              self->nd-1,
+                                              self->dimensions+1,
+                                              self->strides+1, item,
+                                              self->flags,
+                                              (PyObject *)self);
+    if (r == NULL) return NULL;
+    Py_INCREF(self);
+    r->base = (PyObject *)self;
+    PyArray_UpdateFlags(r, CONTIGUOUS | FORTRAN);
+    return (PyObject *)r;
 }
 
 /* contains optimization for 1-d arrays */
 static PyObject *
 array_item_nice(PyArrayObject *self, Py_ssize_t i)
 {
-        if (self->nd == 1) {
-                char *item;
-                if ((item = index2ptr(self, i)) == NULL) return NULL;
-                return PyArray_Scalar(item, self->descr, (PyObject *)self);
-        }
-        else {
-                return PyArray_Return((PyArrayObject *)\
-                                      array_big_item(self, (intp) i));
-        }
+    if (self->nd == 1) {
+        char *item;
+        if ((item = index2ptr(self, i)) == NULL) return NULL;
+        return PyArray_Scalar(item, self->descr, (PyObject *)self);
+    }
+    else {
+        return PyArray_Return((PyArrayObject *)\
+                              array_big_item(self, (intp) i));
+    }
 }
 
 static int
 array_ass_big_item(PyArrayObject *self, intp i, PyObject *v)
 {
-        PyArrayObject *tmp;
-        char *item;
-        int ret;
+    PyArrayObject *tmp;
+    char *item;
+    int ret;
 
-        if (v == NULL) {
-                PyErr_SetString(PyExc_ValueError,
-                                "can't delete array elements");
-                return -1;
-        }
-        if (!PyArray_ISWRITEABLE(self)) {
-                PyErr_SetString(PyExc_RuntimeError,
-                                "array is not writeable");
-                return -1;
-        }
-        if (self->nd == 0) {
-                PyErr_SetString(PyExc_IndexError,
-                                "0-d arrays can't be indexed.");
-                return -1;
-        }
+    if (v == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+                        "can't delete array elements");
+        return -1;
+    }
+    if (!PyArray_ISWRITEABLE(self)) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "array is not writeable");
+        return -1;
+    }
+    if (self->nd == 0) {
+        PyErr_SetString(PyExc_IndexError,
+                        "0-d arrays can't be indexed.");
+        return -1;
+    }
 
 
-        if (self->nd > 1) {
-                if((tmp = (PyArrayObject *)array_big_item(self, i)) == NULL)
-                        return -1;
-                ret = PyArray_CopyObject(tmp, v);
-                Py_DECREF(tmp);
-                return ret;
-        }
+    if (self->nd > 1) {
+        if((tmp = (PyArrayObject *)array_big_item(self, i)) == NULL)
+            return -1;
+        ret = PyArray_CopyObject(tmp, v);
+        Py_DECREF(tmp);
+        return ret;
+    }
 
-        if ((item = index2ptr(self, i)) == NULL) return -1;
-        if (self->descr->f->setitem(v, item, self) == -1) return -1;
-        return 0;
+    if ((item = index2ptr(self, i)) == NULL) return -1;
+    if (self->descr->f->setitem(v, item, self) == -1) return -1;
+    return 0;
 }
 
 #if PY_VERSION_HEX < 0x02050000
- #if SIZEOF_INT == SIZEOF_INTP
- #define array_ass_item array_ass_big_item
- #endif
+#if SIZEOF_INT == SIZEOF_INTP
+#define array_ass_item array_ass_big_item
+#endif
 #else
- #if SIZEOF_SIZE_T == SIZEOF_INTP
- #define array_ass_item array_ass_big_item
- #endif
+#if SIZEOF_SIZE_T == SIZEOF_INTP
+#define array_ass_item array_ass_big_item
+#endif
 #endif
 #ifndef array_ass_item
 static int
 array_ass_item(PyArrayObject *self, Py_ssize_t i, PyObject *v)
 {
-        return array_ass_big_item(self, (intp) i, v);
+    return array_ass_big_item(self, (intp) i, v);
 }
 #endif
 
@@ -2068,12 +2067,12 @@ array_ass_item(PyArrayObject *self, Py_ssize_t i, PyObject *v)
 static int
 slice_coerce_index(PyObject *o, intp *v)
 {
-        *v = PyArray_PyIntAsIntp(o);
-        if (error_converting(*v)) {
-                PyErr_Clear();
-                return 0;
-        }
-        return 1;
+    *v = PyArray_PyIntAsIntp(o);
+    if (error_converting(*v)) {
+        PyErr_Clear();
+        return 0;
+    }
+    return 1;
 }
 
 
@@ -2084,52 +2083,52 @@ slice_GetIndices(PySliceObject *r, intp length,
                  intp *start, intp *stop, intp *step,
                  intp *slicelength)
 {
-        intp defstop;
+    intp defstop;
 
-        if (r->step == Py_None) {
-                *step = 1;
-        } else {
-                if (!slice_coerce_index(r->step, step)) return -1;
-                if (*step == 0) {
-                        PyErr_SetString(PyExc_ValueError,
-                                        "slice step cannot be zero");
-                        return -1;
-                }
+    if (r->step == Py_None) {
+        *step = 1;
+    } else {
+        if (!slice_coerce_index(r->step, step)) return -1;
+        if (*step == 0) {
+            PyErr_SetString(PyExc_ValueError,
+                            "slice step cannot be zero");
+            return -1;
         }
-        /* defstart = *step < 0 ? length - 1 : 0; */
+    }
+    /* defstart = *step < 0 ? length - 1 : 0; */
 
-        defstop = *step < 0 ? -1 : length;
+    defstop = *step < 0 ? -1 : length;
 
-        if (r->start == Py_None) {
-                *start = *step < 0 ? length-1 : 0;
-        } else {
-                if (!slice_coerce_index(r->start, start)) return -1;
-                if (*start < 0) *start += length;
-                if (*start < 0) *start = (*step < 0) ? -1 : 0;
-                if (*start >= length) {
-                        *start = (*step < 0) ? length - 1 : length;
-                }
+    if (r->start == Py_None) {
+        *start = *step < 0 ? length-1 : 0;
+    } else {
+        if (!slice_coerce_index(r->start, start)) return -1;
+        if (*start < 0) *start += length;
+        if (*start < 0) *start = (*step < 0) ? -1 : 0;
+        if (*start >= length) {
+            *start = (*step < 0) ? length - 1 : length;
         }
+    }
 
-        if (r->stop == Py_None) {
-                *stop = defstop;
-        } else {
-                if (!slice_coerce_index(r->stop, stop)) return -1;
-                if (*stop < 0) *stop += length;
+    if (r->stop == Py_None) {
+        *stop = defstop;
+    } else {
+        if (!slice_coerce_index(r->stop, stop)) return -1;
+        if (*stop < 0) *stop += length;
         if (*stop < 0) *stop = -1;
         if (*stop > length) *stop = length;
-        }
+    }
 
-        if ((*step < 0 && *stop >= *start) || \
-            (*step > 0 && *start >= *stop)) {
-                *slicelength = 0;
-        } else if (*step < 0) {
-                *slicelength = (*stop - *start + 1) / (*step) + 1;
-        } else {
-                *slicelength = (*stop - *start - 1) / (*step) + 1;
-        }
+    if ((*step < 0 && *stop >= *start) || \
+        (*step > 0 && *start >= *stop)) {
+        *slicelength = 0;
+    } else if (*step < 0) {
+        *slicelength = (*stop - *start + 1) / (*step) + 1;
+    } else {
+        *slicelength = (*stop - *start - 1) / (*step) + 1;
+    }
 
-        return 0;
+    return 0;
 }
 
 #define PseudoIndex -1
@@ -2139,49 +2138,49 @@ slice_GetIndices(PySliceObject *r, intp length,
 static intp
 parse_subindex(PyObject *op, intp *step_size, intp *n_steps, intp max)
 {
-        intp index;
-
-        if (op == Py_None) {
-                *n_steps = PseudoIndex;
-                index = 0;
-        } else if (op == Py_Ellipsis) {
-                *n_steps = RubberIndex;
-                index = 0;
-        } else if (PySlice_Check(op)) {
-                intp stop;
-                if (slice_GetIndices((PySliceObject *)op, max,
-                                     &index, &stop, step_size, n_steps) < 0) {
-                        if (!PyErr_Occurred()) {
-                                PyErr_SetString(PyExc_IndexError,
-                                                "invalid slice");
-                        }
-                        goto fail;
-                }
-                if (*n_steps <= 0) {
-                        *n_steps = 0;
-                        *step_size = 1;
-                        index = 0;
-                }
-        } else {
-                index = PyArray_PyIntAsIntp(op);
-                if (error_converting(index)) {
-                        PyErr_SetString(PyExc_IndexError,
-                                        "each subindex must be either a "\
-                                        "slice, an integer, Ellipsis, or "\
-                                        "newaxis");
-                        goto fail;
-                }
-                *n_steps = SingleIndex;
-                *step_size = 0;
-                if (index < 0) index += max;
-                if (index >= max || index < 0) {
-                        PyErr_SetString(PyExc_IndexError, "invalid index");
-                        goto fail;
-                }
+    intp index;
+
+    if (op == Py_None) {
+        *n_steps = PseudoIndex;
+        index = 0;
+    } else if (op == Py_Ellipsis) {
+        *n_steps = RubberIndex;
+        index = 0;
+    } else if (PySlice_Check(op)) {
+        intp stop;
+        if (slice_GetIndices((PySliceObject *)op, max,
+                             &index, &stop, step_size, n_steps) < 0) {
+            if (!PyErr_Occurred()) {
+                PyErr_SetString(PyExc_IndexError,
+                                "invalid slice");
+            }
+            goto fail;
+        }
+        if (*n_steps <= 0) {
+            *n_steps = 0;
+            *step_size = 1;
+            index = 0;
+        }
+    } else {
+        index = PyArray_PyIntAsIntp(op);
+        if (error_converting(index)) {
+            PyErr_SetString(PyExc_IndexError,
+                            "each subindex must be either a "\
+                            "slice, an integer, Ellipsis, or "\
+                            "newaxis");
+            goto fail;
+        }
+        *n_steps = SingleIndex;
+        *step_size = 0;
+        if (index < 0) index += max;
+        if (index >= max || index < 0) {
+            PyErr_SetString(PyExc_IndexError, "invalid index");
+            goto fail;
         }
-        return index;
+    }
+    return index;
  fail:
-        return -1;
+    return -1;
 }
 
 
@@ -2189,168 +2188,168 @@ static int
 parse_index(PyArrayObject *self, PyObject *op,
             intp *dimensions, intp *strides, intp *offset_ptr)
 {
-        int i, j, n;
-        int nd_old, nd_new, n_add, n_pseudo;
-        intp n_steps, start, offset, step_size;
-        PyObject *op1=NULL;
-        int is_slice;
+    int i, j, n;
+    int nd_old, nd_new, n_add, n_pseudo;
+    intp n_steps, start, offset, step_size;
+    PyObject *op1=NULL;
+    int is_slice;
 
-        if (PySlice_Check(op) || op == Py_Ellipsis || op == Py_None) {
-                n = 1;
-                op1 = op;
-                Py_INCREF(op);
-                /* this relies on the fact that n==1 for loop below */
-                is_slice = 1;
-        }
-        else {
-                if (!PySequence_Check(op)) {
-                        PyErr_SetString(PyExc_IndexError,
-                                        "index must be either an int "\
-                                        "or a sequence");
-                        return -1;
-                }
-                n = PySequence_Length(op);
-                is_slice = 0;
-        }
+    if (PySlice_Check(op) || op == Py_Ellipsis || op == Py_None) {
+        n = 1;
+        op1 = op;
+        Py_INCREF(op);
+        /* this relies on the fact that n==1 for loop below */
+        is_slice = 1;
+    }
+    else {
+        if (!PySequence_Check(op)) {
+            PyErr_SetString(PyExc_IndexError,
+                            "index must be either an int "\
+                            "or a sequence");
+            return -1;
+        }
+        n = PySequence_Length(op);
+        is_slice = 0;
+    }
 
-        nd_old = nd_new = 0;
+    nd_old = nd_new = 0;
 
-        offset = 0;
-        for(i=0; i<n; i++) {
-                if (!is_slice) {
-                        if (!(op1=PySequence_GetItem(op, i))) {
-                                PyErr_SetString(PyExc_IndexError,
-                                                "invalid index");
-                                return -1;
-                        }
-                }
+    offset = 0;
+    for(i=0; i<n; i++) {
+        if (!is_slice) {
+            if (!(op1=PySequence_GetItem(op, i))) {
+                PyErr_SetString(PyExc_IndexError,
+                                "invalid index");
+                return -1;
+            }
+        }
 
-                start = parse_subindex(op1, &step_size, &n_steps,
-                                       nd_old < self->nd ? \
-                                       self->dimensions[nd_old] : 0);
-                Py_DECREF(op1);
-                if (start == -1) break;
+        start = parse_subindex(op1, &step_size, &n_steps,
+                               nd_old < self->nd ? \
+                               self->dimensions[nd_old] : 0);
+        Py_DECREF(op1);
+        if (start == -1) break;
 
-                if (n_steps == PseudoIndex) {
-                        dimensions[nd_new] = 1; strides[nd_new] = 0;
-                        nd_new++;
-                } else {
-                        if (n_steps == RubberIndex) {
-                                for(j=i+1, n_pseudo=0; j<n; j++) {
-                                        op1 = PySequence_GetItem(op, j);
-                                        if (op1 == Py_None) n_pseudo++;
-                                        Py_DECREF(op1);
-                                }
-                                n_add = self->nd-(n-i-n_pseudo-1+nd_old);
-                                if (n_add < 0) {
-                                        PyErr_SetString(PyExc_IndexError,
-                                                        "too many indices");
-                                        return -1;
-                                }
-                                for(j=0; j<n_add; j++) {
-                                        dimensions[nd_new] = \
-                                                self->dimensions[nd_old];
-                                        strides[nd_new] = \
-                                                self->strides[nd_old];
-                                        nd_new++; nd_old++;
-                                }
-                        } else {
-                                if (nd_old >= self->nd) {
-                                        PyErr_SetString(PyExc_IndexError,
-                                                        "too many indices");
-                                        return -1;
-                                }
-                                offset += self->strides[nd_old]*start;
-                                nd_old++;
-                                if (n_steps != SingleIndex) {
-                                        dimensions[nd_new] = n_steps;
-                                        strides[nd_new] = step_size * \
-                                                self->strides[nd_old-1];
-                                        nd_new++;
-                                }
-                        }
+        if (n_steps == PseudoIndex) {
+            dimensions[nd_new] = 1; strides[nd_new] = 0;
+            nd_new++;
+        } else {
+            if (n_steps == RubberIndex) {
+                for(j=i+1, n_pseudo=0; j<n; j++) {
+                    op1 = PySequence_GetItem(op, j);
+                    if (op1 == Py_None) n_pseudo++;
+                    Py_DECREF(op1);
+                }
+                n_add = self->nd-(n-i-n_pseudo-1+nd_old);
+                if (n_add < 0) {
+                    PyErr_SetString(PyExc_IndexError,
+                                    "too many indices");
+                    return -1;
+                }
+                for(j=0; j<n_add; j++) {
+                    dimensions[nd_new] = \
+                        self->dimensions[nd_old];
+                    strides[nd_new] = \
+                        self->strides[nd_old];
+                    nd_new++; nd_old++;
                 }
+            } else {
+                if (nd_old >= self->nd) {
+                    PyErr_SetString(PyExc_IndexError,
+                                    "too many indices");
+                    return -1;
+                }
+                offset += self->strides[nd_old]*start;
+                nd_old++;
+                if (n_steps != SingleIndex) {
+                    dimensions[nd_new] = n_steps;
+                    strides[nd_new] = step_size * \
+                        self->strides[nd_old-1];
+                    nd_new++;
+                }
+            }
         }
-        if (i < n) return -1;
-        n_add = self->nd-nd_old;
-        for(j=0; j<n_add; j++) {
-                dimensions[nd_new] = self->dimensions[nd_old];
-                strides[nd_new] = self->strides[nd_old];
-                nd_new++; nd_old++;
-        }
-        *offset_ptr = offset;
-        return nd_new;
+    }
+    if (i < n) return -1;
+    n_add = self->nd-nd_old;
+    for(j=0; j<n_add; j++) {
+        dimensions[nd_new] = self->dimensions[nd_old];
+        strides[nd_new] = self->strides[nd_old];
+        nd_new++; nd_old++;
+    }
+    *offset_ptr = offset;
+    return nd_new;
 }
 
 static void
 _swap_axes(PyArrayMapIterObject *mit, PyArrayObject **ret, int getmap)
 {
-        PyObject *new;
-        int n1, n2, n3, val, bnd;
-        int i;
-        PyArray_Dims permute;
-        intp d[MAX_DIMS];
-        PyArrayObject *arr;
-
-        permute.ptr = d;
-        permute.len = mit->nd;
-
-        /* arr might not have the right number of dimensions
-           and need to be reshaped first by pre-pending ones */
-        arr = *ret;
-        if (arr->nd != mit->nd) {
-                for (i=1; i<=arr->nd; i++) {
-                        permute.ptr[mit->nd-i] = arr->dimensions[arr->nd-i];
-                }
-                for (i=0; i<mit->nd-arr->nd; i++) {
-                        permute.ptr[i] = 1;
-                }
-                new = PyArray_Newshape(arr, &permute, PyArray_ANYORDER);
-                Py_DECREF(arr);
-                *ret = (PyArrayObject *)new;
-                if (new == NULL) return;
-        }
-
-        /* Setting and getting need to have different permutations.
-           On the get we are permuting the returned object, but on
-           setting we are permuting the object-to-be-set. 
-           The set permutation is the inverse of the get permutation.
-        */
+    PyObject *new;
+    int n1, n2, n3, val, bnd;
+    int i;
+    PyArray_Dims permute;
+    intp d[MAX_DIMS];
+    PyArrayObject *arr;
 
-        /* For getting the array the tuple for transpose is
-           (n1,...,n1+n2-1,0,...,n1-1,n1+n2,...,n3-1)
-           n1 is the number of dimensions of
-              the broadcasted index array
-           n2 is the number of dimensions skipped at the
-              start 
-           n3 is the number of dimensions of the
-              result
-        */
+    permute.ptr = d;
+    permute.len = mit->nd;
 
-        /* For setting the array the tuple for transpose is
-           (n2,...,n1+n2-1,0,...,n2-1,n1+n2,...n3-1)
-        */
-        n1 = mit->iters[0]->nd_m1 + 1;
-        n2 = mit->iteraxes[0];
-        n3 = mit->nd;
-
-        bnd = (getmap ? n1 : n2); /* use n1 as the boundary if getting
-                                      but n2 if setting */
-        
-        val = bnd;
-        i = 0;
-        while(val < n1+n2)
-                permute.ptr[i++] = val++;
-        val = 0;
-        while(val < bnd)
-                permute.ptr[i++] = val++;
-        val = n1+n2;
-        while(val < n3)
-                permute.ptr[i++] = val++;
-
-        new = PyArray_Transpose(*ret, &permute);
-        Py_DECREF(*ret);
+    /* arr might not have the right number of dimensions
+       and need to be reshaped first by pre-pending ones */
+    arr = *ret;
+    if (arr->nd != mit->nd) {
+        for (i=1; i<=arr->nd; i++) {
+            permute.ptr[mit->nd-i] = arr->dimensions[arr->nd-i];
+        }
+        for (i=0; i<mit->nd-arr->nd; i++) {
+            permute.ptr[i] = 1;
+        }
+        new = PyArray_Newshape(arr, &permute, PyArray_ANYORDER);
+        Py_DECREF(arr);
         *ret = (PyArrayObject *)new;
+        if (new == NULL) return;
+    }
+
+    /* Setting and getting need to have different permutations.
+       On the get we are permuting the returned object, but on
+       setting we are permuting the object-to-be-set.
+       The set permutation is the inverse of the get permutation.
+    */
+
+    /* For getting the array the tuple for transpose is
+       (n1,...,n1+n2-1,0,...,n1-1,n1+n2,...,n3-1)
+       n1 is the number of dimensions of
+       the broadcasted index array
+       n2 is the number of dimensions skipped at the
+       start
+       n3 is the number of dimensions of the
+       result
+    */
+
+    /* For setting the array the tuple for transpose is
+       (n2,...,n1+n2-1,0,...,n2-1,n1+n2,...n3-1)
+    */
+    n1 = mit->iters[0]->nd_m1 + 1;
+    n2 = mit->iteraxes[0];
+    n3 = mit->nd;
+
+    bnd = (getmap ? n1 : n2); /* use n1 as the boundary if getting
+                                 but n2 if setting */
+
+    val = bnd;
+    i = 0;
+    while(val < n1+n2)
+        permute.ptr[i++] = val++;
+    val = 0;
+    while(val < bnd)
+        permute.ptr[i++] = val++;
+    val = n1+n2;
+    while(val < n3)
+        permute.ptr[i++] = val++;
+
+    new = PyArray_Transpose(*ret, &permute);
+    Py_DECREF(*ret);
+    *ret = (PyArrayObject *)new;
 }
 
 /* Prototypes for Mapping calls --- not part of the C-API
@@ -2366,175 +2365,175 @@ static PyObject *
 PyArray_GetMap(PyArrayMapIterObject *mit)
 {
 
-        PyArrayObject *ret, *temp;
-        PyArrayIterObject *it;
-        int index;
-        int swap;
-        PyArray_CopySwapFunc *copyswap;
-
-        /* Unbound map iterator --- Bind should have been called */
-        if (mit->ait == NULL) return NULL;
-
-        /* This relies on the map iterator object telling us the shape
-           of the new array in nd and dimensions.
-        */
-        temp = mit->ait->ao;
-        Py_INCREF(temp->descr);
-        ret = (PyArrayObject *)\
-                PyArray_NewFromDescr(temp->ob_type,
-                                     temp->descr,
-                                     mit->nd, mit->dimensions,
-                                     NULL, NULL,
-                                     PyArray_ISFORTRAN(temp),
-                                     (PyObject *)temp);
-        if (ret == NULL) return NULL;
-
-        /* Now just iterate through the new array filling it in
-           with the next object from the original array as
-           defined by the mapping iterator */
-
-        if ((it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)ret))
-            == NULL) {
-                Py_DECREF(ret);
-                return NULL;
-        }
-        index = it->size;
-        swap = (PyArray_ISNOTSWAPPED(temp) != PyArray_ISNOTSWAPPED(ret));
-        copyswap = ret->descr->f->copyswap;
-        PyArray_MapIterReset(mit);
-        while (index--) {
-                copyswap(it->dataptr, mit->dataptr, swap, ret);
-                PyArray_MapIterNext(mit);
-                PyArray_ITER_NEXT(it);
-        }
-        Py_DECREF(it);
+    PyArrayObject *ret, *temp;
+    PyArrayIterObject *it;
+    int index;
+    int swap;
+    PyArray_CopySwapFunc *copyswap;
+
+    /* Unbound map iterator --- Bind should have been called */
+    if (mit->ait == NULL) return NULL;
+
+    /* This relies on the map iterator object telling us the shape
+       of the new array in nd and dimensions.
+    */
+    temp = mit->ait->ao;
+    Py_INCREF(temp->descr);
+    ret = (PyArrayObject *)\
+        PyArray_NewFromDescr(temp->ob_type,
+                             temp->descr,
+                             mit->nd, mit->dimensions,
+                             NULL, NULL,
+                             PyArray_ISFORTRAN(temp),
+                             (PyObject *)temp);
+    if (ret == NULL) return NULL;
+
+    /* Now just iterate through the new array filling it in
+       with the next object from the original array as
+       defined by the mapping iterator */
+
+    if ((it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)ret))
+        == NULL) {
+        Py_DECREF(ret);
+        return NULL;
+    }
+    index = it->size;
+    swap = (PyArray_ISNOTSWAPPED(temp) != PyArray_ISNOTSWAPPED(ret));
+    copyswap = ret->descr->f->copyswap;
+    PyArray_MapIterReset(mit);
+    while (index--) {
+        copyswap(it->dataptr, mit->dataptr, swap, ret);
+        PyArray_MapIterNext(mit);
+        PyArray_ITER_NEXT(it);
+    }
+    Py_DECREF(it);
 
-        /* check for consecutive axes */
-        if ((mit->subspace != NULL) && (mit->consec)) {
-                if (mit->iteraxes[0] > 0) {  /* then we need to swap */
-                        _swap_axes(mit, &ret, 1);
-                }
+    /* check for consecutive axes */
+    if ((mit->subspace != NULL) && (mit->consec)) {
+        if (mit->iteraxes[0] > 0) {  /* then we need to swap */
+            _swap_axes(mit, &ret, 1);
         }
-        return (PyObject *)ret;
+    }
+    return (PyObject *)ret;
 }
 
 static int
 PyArray_SetMap(PyArrayMapIterObject *mit, PyObject *op)
 {
-        PyObject *arr=NULL;
-        PyArrayIterObject *it;
-        int index;
-        int swap;
-        PyArray_CopySwapFunc *copyswap;
-        PyArray_Descr *descr;
+    PyObject *arr=NULL;
+    PyArrayIterObject *it;
+    int index;
+    int swap;
+    PyArray_CopySwapFunc *copyswap;
+    PyArray_Descr *descr;
 
-        /* Unbound Map Iterator */
-        if (mit->ait == NULL) return -1;
+    /* Unbound Map Iterator */
+    if (mit->ait == NULL) return -1;
 
-        descr = mit->ait->ao->descr;
-        Py_INCREF(descr);
-        arr = PyArray_FromAny(op, descr, 0, 0, FORCECAST, NULL);
-        if (arr == NULL) return -1;
+    descr = mit->ait->ao->descr;
+    Py_INCREF(descr);
+    arr = PyArray_FromAny(op, descr, 0, 0, FORCECAST, NULL);
+    if (arr == NULL) return -1;
 
-        if ((mit->subspace != NULL) && (mit->consec)) {
-                if (mit->iteraxes[0] > 0) {  /* then we need to swap */
-                        _swap_axes(mit, (PyArrayObject **)&arr, 0);
-                        if (arr == NULL) return -1;
-                }
+    if ((mit->subspace != NULL) && (mit->consec)) {
+        if (mit->iteraxes[0] > 0) {  /* then we need to swap */
+            _swap_axes(mit, (PyArrayObject **)&arr, 0);
+            if (arr == NULL) return -1;
         }
+    }
 
-        /* Be sure values array is "broadcastable"
-           to shape of mit->dimensions, mit->nd */
+    /* Be sure values array is "broadcastable"
+       to shape of mit->dimensions, mit->nd */
 
-        if ((it = (PyArrayIterObject *)\
-             PyArray_BroadcastToShape(arr, mit->dimensions, mit->nd))==NULL) {
-                Py_DECREF(arr);
-                return -1;
-        }
+    if ((it = (PyArrayIterObject *)\
+         PyArray_BroadcastToShape(arr, mit->dimensions, mit->nd))==NULL) {
+        Py_DECREF(arr);
+        return -1;
+    }
 
-        index = mit->size;
-        swap = (PyArray_ISNOTSWAPPED(mit->ait->ao) != \
-                (PyArray_ISNOTSWAPPED(arr)));
-        copyswap = PyArray_DESCR(arr)->f->copyswap;
-        PyArray_MapIterReset(mit);
-        /* Need to decref hasobject arrays */
-        if (PyDataType_FLAGCHK(descr, NPY_ITEM_REFCOUNT)) {
-                while (index--) {
-                        PyArray_Item_XDECREF(mit->dataptr, PyArray_DESCR(arr));
-                        PyArray_Item_INCREF(it->dataptr, PyArray_DESCR(arr));
-                        memmove(mit->dataptr, it->dataptr, sizeof(PyObject *));
-                        /* ignored unless VOID array with object's */
-                        if (swap)
-                                copyswap(mit->dataptr, NULL, swap, arr);
-                        PyArray_MapIterNext(mit);
-                        PyArray_ITER_NEXT(it);
-                }
-                Py_DECREF(arr);
-                Py_DECREF(it);
-                return 0;
-        }
-        while(index--) {
-                memmove(mit->dataptr, it->dataptr, PyArray_ITEMSIZE(arr));
-                if (swap)
-                        copyswap(mit->dataptr, NULL, swap, arr);
-                PyArray_MapIterNext(mit);
-                PyArray_ITER_NEXT(it);
+    index = mit->size;
+    swap = (PyArray_ISNOTSWAPPED(mit->ait->ao) != \
+            (PyArray_ISNOTSWAPPED(arr)));
+    copyswap = PyArray_DESCR(arr)->f->copyswap;
+    PyArray_MapIterReset(mit);
+    /* Need to decref hasobject arrays */
+    if (PyDataType_FLAGCHK(descr, NPY_ITEM_REFCOUNT)) {
+        while (index--) {
+            PyArray_Item_XDECREF(mit->dataptr, PyArray_DESCR(arr));
+            PyArray_Item_INCREF(it->dataptr, PyArray_DESCR(arr));
+            memmove(mit->dataptr, it->dataptr, sizeof(PyObject *));
+            /* ignored unless VOID array with object's */
+            if (swap)
+                copyswap(mit->dataptr, NULL, swap, arr);
+            PyArray_MapIterNext(mit);
+            PyArray_ITER_NEXT(it);
         }
         Py_DECREF(arr);
         Py_DECREF(it);
         return 0;
+    }
+    while(index--) {
+        memmove(mit->dataptr, it->dataptr, PyArray_ITEMSIZE(arr));
+        if (swap)
+            copyswap(mit->dataptr, NULL, swap, arr);
+        PyArray_MapIterNext(mit);
+        PyArray_ITER_NEXT(it);
+    }
+    Py_DECREF(arr);
+    Py_DECREF(it);
+    return 0;
 }
 
 int
 count_new_axes_0d(PyObject *tuple)
 {
-        int i, argument_count;
-        int ellipsis_count = 0;
-        int newaxis_count = 0;
+    int i, argument_count;
+    int ellipsis_count = 0;
+    int newaxis_count = 0;
 
-        argument_count = PyTuple_GET_SIZE(tuple);
+    argument_count = PyTuple_GET_SIZE(tuple);
 
-        for (i = 0; i < argument_count; ++i) {
-                PyObject *arg = PyTuple_GET_ITEM(tuple, i);
-                if (arg == Py_Ellipsis && !ellipsis_count) ellipsis_count++;
-                else if (arg == Py_None) newaxis_count++;
-                else break;
-        }
-        if (i < argument_count) {
-                PyErr_SetString(PyExc_IndexError,
-                                "0-d arrays can only use a single ()"
-                                " or a list of newaxes (and a single ...)"
-                                " as an index");
-                return -1;
-        }
-        if (newaxis_count > MAX_DIMS) {
-                PyErr_SetString(PyExc_IndexError,
-                                "too many dimensions");
-                return -1;
-        }
-        return newaxis_count;
+    for (i = 0; i < argument_count; ++i) {
+        PyObject *arg = PyTuple_GET_ITEM(tuple, i);
+        if (arg == Py_Ellipsis && !ellipsis_count) ellipsis_count++;
+        else if (arg == Py_None) newaxis_count++;
+        else break;
+    }
+    if (i < argument_count) {
+        PyErr_SetString(PyExc_IndexError,
+                        "0-d arrays can only use a single ()"
+                        " or a list of newaxes (and a single ...)"
+                        " as an index");
+        return -1;
+    }
+    if (newaxis_count > MAX_DIMS) {
+        PyErr_SetString(PyExc_IndexError,
+                        "too many dimensions");
+        return -1;
+    }
+    return newaxis_count;
 }
 
 static PyObject *
 add_new_axes_0d(PyArrayObject *arr,  int newaxis_count)
 {
-        PyArrayObject *other;
-        intp dimensions[MAX_DIMS];
-        int i;
-        for (i = 0; i < newaxis_count; ++i) {
-                dimensions[i]  = 1;
-        }
-        Py_INCREF(arr->descr);
-        if ((other = (PyArrayObject *)
-             PyArray_NewFromDescr(arr->ob_type, arr->descr,
-                                  newaxis_count, dimensions,
-                                  NULL, arr->data,
-                                  arr->flags,
-                                  (PyObject *)arr)) == NULL)
-                return NULL;
-        other->base = (PyObject *)arr;
-        Py_INCREF(arr);
-        return (PyObject *)other;
+    PyArrayObject *other;
+    intp dimensions[MAX_DIMS];
+    int i;
+    for (i = 0; i < newaxis_count; ++i) {
+        dimensions[i]  = 1;
+    }
+    Py_INCREF(arr->descr);
+    if ((other = (PyArrayObject *)
+         PyArray_NewFromDescr(arr->ob_type, arr->descr,
+                              newaxis_count, dimensions,
+                              NULL, arr->data,
+                              arr->flags,
+                              (PyObject *)arr)) == NULL)
+        return NULL;
+    other->base = (PyObject *)arr;
+    Py_INCREF(arr);
+    return (PyObject *)other;
 }
 
 
@@ -2549,67 +2548,67 @@ add_new_axes_0d(PyArrayObject *arr,  int newaxis_count)
 static int
 fancy_indexing_check(PyObject *args)
 {
-        int i, n;
-        PyObject *obj;
-        int retval = SOBJ_NOTFANCY;
-
-        if (PyTuple_Check(args)) {
-                n = PyTuple_GET_SIZE(args);
-                if (n >= MAX_DIMS) return SOBJ_TOOMANY;
-                for (i=0; i<n; i++) {
-                        obj = PyTuple_GET_ITEM(args,i);
-                        if (PyArray_Check(obj)) {
-                                if (PyArray_ISINTEGER(obj) || 
-                                    PyArray_ISBOOL(obj))
-                                        retval = SOBJ_ISFANCY;
-                                else {
-                                        retval = SOBJ_BADARRAY;
-                                        break;
-                                }
-                        }
-                        else if (PySequence_Check(obj)) {
-                                retval = SOBJ_ISFANCY;
-                        }
+    int i, n;
+    PyObject *obj;
+    int retval = SOBJ_NOTFANCY;
+
+    if (PyTuple_Check(args)) {
+        n = PyTuple_GET_SIZE(args);
+        if (n >= MAX_DIMS) return SOBJ_TOOMANY;
+        for (i=0; i<n; i++) {
+            obj = PyTuple_GET_ITEM(args,i);
+            if (PyArray_Check(obj)) {
+                if (PyArray_ISINTEGER(obj) ||
+                    PyArray_ISBOOL(obj))
+                    retval = SOBJ_ISFANCY;
+                else {
+                    retval = SOBJ_BADARRAY;
+                    break;
                 }
+            }
+            else if (PySequence_Check(obj)) {
+                retval = SOBJ_ISFANCY;
+            }
         }
-        else if (PyArray_Check(args)) {
-                if ((PyArray_TYPE(args)==PyArray_BOOL) ||
-                    (PyArray_ISINTEGER(args)))
-                        return SOBJ_ISFANCY;
+    }
+    else if (PyArray_Check(args)) {
+        if ((PyArray_TYPE(args)==PyArray_BOOL) ||
+            (PyArray_ISINTEGER(args)))
+            return SOBJ_ISFANCY;
+        else
+            return SOBJ_BADARRAY;
+    }
+    else if (PySequence_Check(args)) {
+        /* Sequences < MAX_DIMS with any slice objects
+           or newaxis, or Ellipsis is considered standard
+           as long as there are also no Arrays and or additional
+           sequences embedded.
+        */
+        retval = SOBJ_ISFANCY;
+        n = PySequence_Size(args);
+        if (n<0 || n>=MAX_DIMS) return SOBJ_ISFANCY;
+        for (i=0; i<n; i++) {
+            obj = PySequence_GetItem(args, i);
+            if (obj == NULL) return SOBJ_ISFANCY;
+            if (PyArray_Check(obj)) {
+                if (PyArray_ISINTEGER(obj) ||
+                    PyArray_ISBOOL(obj))
+                    retval = SOBJ_LISTTUP;
                 else
-                        return SOBJ_BADARRAY;
-        }
-        else if (PySequence_Check(args)) {
-                /* Sequences < MAX_DIMS with any slice objects
-                   or newaxis, or Ellipsis is considered standard
-                   as long as there are also no Arrays and or additional
-                   sequences embedded.
-                */
-                retval = SOBJ_ISFANCY;
-                n = PySequence_Size(args);
-                if (n<0 || n>=MAX_DIMS) return SOBJ_ISFANCY;
-                for (i=0; i<n; i++) {
-                        obj = PySequence_GetItem(args, i);
-                        if (obj == NULL) return SOBJ_ISFANCY;
-                        if (PyArray_Check(obj)) {
-                                if (PyArray_ISINTEGER(obj) ||
-                                    PyArray_ISBOOL(obj))
-                                        retval = SOBJ_LISTTUP;
-                                else
-                                        retval = SOBJ_BADARRAY;
-                        }
-                        else if (PySequence_Check(obj)) {
-                                retval = SOBJ_LISTTUP;
-                        }
-                        else if (PySlice_Check(obj) || obj == Py_Ellipsis || 
-                                 obj == Py_None) {
-                                retval = SOBJ_NOTFANCY;
-                        }
-                        Py_DECREF(obj);
-                        if (retval > SOBJ_ISFANCY) return retval;
-                }
+                    retval = SOBJ_BADARRAY;
+            }
+            else if (PySequence_Check(obj)) {
+                retval = SOBJ_LISTTUP;
+            }
+            else if (PySlice_Check(obj) || obj == Py_Ellipsis ||
+                     obj == Py_None) {
+                retval = SOBJ_NOTFANCY;
+            }
+            Py_DECREF(obj);
+            if (retval > SOBJ_ISFANCY) return retval;
         }
-        return retval;
+    }
+    return retval;
 }
 
 /* Called when treating array object like a mapping -- called first from
@@ -2620,11 +2619,11 @@ fancy_indexing_check(PyObject *args)
 
 /* There are two situations:
 
-     1 - the subscript is a standard view and a reference to the
-         array can be returned
+   1 - the subscript is a standard view and a reference to the
+   array can be returned
 
-     2 - the subscript uses Boolean masks or integer indexing and
-         therefore a new array is created and returned.
+   2 - the subscript uses Boolean masks or integer indexing and
+   therefore a new array is created and returned.
 
 */
 
@@ -2636,143 +2635,143 @@ static PyObject *iter_subscript(PyArrayIterObject *, PyObject *);
 static PyObject *
 array_subscript_simple(PyArrayObject *self, PyObject *op)
 {
-        intp dimensions[MAX_DIMS], strides[MAX_DIMS];
-        intp offset;
-        int nd;
-        PyArrayObject *other;
-        intp value;
-
-        value = PyArray_PyIntAsIntp(op);
-        if (!PyErr_Occurred()) {
-                return array_big_item(self, value);
-        }
-        PyErr_Clear();
+    intp dimensions[MAX_DIMS], strides[MAX_DIMS];
+    intp offset;
+    int nd;
+    PyArrayObject *other;
+    intp value;
 
-        /* Standard (view-based) Indexing */
-        if ((nd = parse_index(self, op, dimensions, strides, &offset))
-            == -1) return NULL;
-
-        /* This will only work if new array will be a view */
-        Py_INCREF(self->descr);
-        if ((other = (PyArrayObject *)                                  \
-             PyArray_NewFromDescr(self->ob_type, self->descr,
-                                  nd, dimensions,
-                                  strides, self->data+offset,
-                                  self->flags,
-                                  (PyObject *)self)) == NULL)
-                return NULL;
+    value = PyArray_PyIntAsIntp(op);
+    if (!PyErr_Occurred()) {
+        return array_big_item(self, value);
+    }
+    PyErr_Clear();
+
+    /* Standard (view-based) Indexing */
+    if ((nd = parse_index(self, op, dimensions, strides, &offset))
+        == -1) return NULL;
+
+    /* This will only work if new array will be a view */
+    Py_INCREF(self->descr);
+    if ((other = (PyArrayObject *)                                  \
+         PyArray_NewFromDescr(self->ob_type, self->descr,
+                              nd, dimensions,
+                              strides, self->data+offset,
+                              self->flags,
+                              (PyObject *)self)) == NULL)
+        return NULL;
 
-        other->base = (PyObject *)self;
-        Py_INCREF(self);
+    other->base = (PyObject *)self;
+    Py_INCREF(self);
 
-        PyArray_UpdateFlags(other, UPDATE_ALL);
+    PyArray_UpdateFlags(other, UPDATE_ALL);
 
-        return (PyObject *)other;
+    return (PyObject *)other;
 }
 
 static PyObject *
 array_subscript(PyArrayObject *self, PyObject *op)
 {
-        int nd, fancy;
-        PyArrayObject *other;
-        PyArrayMapIterObject *mit;
+    int nd, fancy;
+    PyArrayObject *other;
+    PyArrayMapIterObject *mit;
 
-        if (PyString_Check(op) || PyUnicode_Check(op)) {
-                if (self->descr->names) {
-                        PyObject *obj;
-                        obj = PyDict_GetItem(self->descr->fields, op);
-                        if (obj != NULL) {
-                                PyArray_Descr *descr;
-                                int offset;
-                                PyObject *title;
-
-                                if (PyArg_ParseTuple(obj, "Oi|O",
-                                                     &descr, &offset, &title)) {
-                                        Py_INCREF(descr);
-                                        return PyArray_GetField(self, descr,
-                                                                offset);
-                                }
-                        }
-                }
+    if (PyString_Check(op) || PyUnicode_Check(op)) {
+        if (self->descr->names) {
+            PyObject *obj;
+            obj = PyDict_GetItem(self->descr->fields, op);
+            if (obj != NULL) {
+                PyArray_Descr *descr;
+                int offset;
+                PyObject *title;
 
-                PyErr_Format(PyExc_ValueError,
-                             "field named %s not found.",
-                             PyString_AsString(op));
-                return NULL;
+                if (PyArg_ParseTuple(obj, "Oi|O",
+                                     &descr, &offset, &title)) {
+                    Py_INCREF(descr);
+                    return PyArray_GetField(self, descr,
+                                            offset);
+                }
+            }
         }
 
-        if (self->nd == 0) {
-                if (op == Py_Ellipsis) {
-                        /* XXX: This leads to a small inconsistency
-                           XXX: with the nd>0 case where (x[...] is x)
-                           XXX: is false for nd>0 case. */
-                        Py_INCREF(self);
-                        return (PyObject *)self;
-                }
-                if (op == Py_None)
-                        return add_new_axes_0d(self, 1);
-                if (PyTuple_Check(op)) {
-                        if (0 == PyTuple_GET_SIZE(op))  {
-                                Py_INCREF(self);
-                                return (PyObject *)self;
-                        }
-                        if ((nd = count_new_axes_0d(op)) == -1)
-                                return NULL;
-                        return add_new_axes_0d(self, nd);
-                }
-                /* Allow Boolean mask selection also */
-                if (PyBool_Check(op) || PyArray_IsScalar(op, Bool) || 
-                    (PyArray_Check(op) && (PyArray_DIMS(op)==0) &&
-                     PyArray_ISBOOL(op))) {
-                        if (PyObject_IsTrue(op)) {
-                                Py_INCREF(self);
-                                return (PyObject *)self;
-                        }
-                        else {
-                                intp oned = 0;
-                                Py_INCREF(self->descr);
-                                return PyArray_NewFromDescr(self->ob_type,
-                                                            self->descr,
-                                                            1, &oned,
-                                                            NULL, NULL,
-                                                            NPY_DEFAULT,
-                                                            NULL);
-                        }
-                }
-                PyErr_SetString(PyExc_IndexError,
-                                "0-d arrays can't be indexed.");
+        PyErr_Format(PyExc_ValueError,
+                     "field named %s not found.",
+                     PyString_AsString(op));
+        return NULL;
+    }
+
+    if (self->nd == 0) {
+        if (op == Py_Ellipsis) {
+            /* XXX: This leads to a small inconsistency
+               XXX: with the nd>0 case where (x[...] is x)
+               XXX: is false for nd>0 case. */
+            Py_INCREF(self);
+            return (PyObject *)self;
+        }
+        if (op == Py_None)
+            return add_new_axes_0d(self, 1);
+        if (PyTuple_Check(op)) {
+            if (0 == PyTuple_GET_SIZE(op))  {
+                Py_INCREF(self);
+                return (PyObject *)self;
+            }
+            if ((nd = count_new_axes_0d(op)) == -1)
                 return NULL;
+            return add_new_axes_0d(self, nd);
         }
-
-        fancy = fancy_indexing_check(op);
-
-        if (fancy != SOBJ_NOTFANCY) {
-                int oned;
-                oned = ((self->nd == 1) &&
-                        !(PyTuple_Check(op) && PyTuple_GET_SIZE(op) > 1));
-
-                /* wrap arguments into a mapiter object */
-                mit = (PyArrayMapIterObject *)\
-                        PyArray_MapIterNew(op, oned, fancy);
-                if (mit == NULL) return NULL;
-                if (oned) {
-                        PyArrayIterObject *it;
-                        PyObject *rval;
-                        it = (PyArrayIterObject *)\
-                                PyArray_IterNew((PyObject *)self);
-                        if (it == NULL) {Py_DECREF(mit); return NULL;}
-                        rval = iter_subscript(it, mit->indexobj);
-                        Py_DECREF(it);
-                        Py_DECREF(mit);
-                        return rval;
-                }
-                PyArray_MapIterBind(mit, self);
-                other = (PyArrayObject *)PyArray_GetMap(mit);
-                Py_DECREF(mit);
-                return (PyObject *)other;
+        /* Allow Boolean mask selection also */
+        if (PyBool_Check(op) || PyArray_IsScalar(op, Bool) ||
+            (PyArray_Check(op) && (PyArray_DIMS(op)==0) &&
+             PyArray_ISBOOL(op))) {
+            if (PyObject_IsTrue(op)) {
+                Py_INCREF(self);
+                return (PyObject *)self;
+            }
+            else {
+                intp oned = 0;
+                Py_INCREF(self->descr);
+                return PyArray_NewFromDescr(self->ob_type,
+                                            self->descr,
+                                            1, &oned,
+                                            NULL, NULL,
+                                            NPY_DEFAULT,
+                                            NULL);
+            }
         }
+        PyErr_SetString(PyExc_IndexError,
+                        "0-d arrays can't be indexed.");
+        return NULL;
+    }
+
+    fancy = fancy_indexing_check(op);
+
+    if (fancy != SOBJ_NOTFANCY) {
+        int oned;
+        oned = ((self->nd == 1) &&
+                !(PyTuple_Check(op) && PyTuple_GET_SIZE(op) > 1));
+
+        /* wrap arguments into a mapiter object */
+        mit = (PyArrayMapIterObject *)\
+            PyArray_MapIterNew(op, oned, fancy);
+        if (mit == NULL) return NULL;
+        if (oned) {
+            PyArrayIterObject *it;
+            PyObject *rval;
+            it = (PyArrayIterObject *)\
+                PyArray_IterNew((PyObject *)self);
+            if (it == NULL) {Py_DECREF(mit); return NULL;}
+            rval = iter_subscript(it, mit->indexobj);
+            Py_DECREF(it);
+            Py_DECREF(mit);
+            return rval;
+        }
+        PyArray_MapIterBind(mit, self);
+        other = (PyArrayObject *)PyArray_GetMap(mit);
+        Py_DECREF(mit);
+        return (PyObject *)other;
+    }
 
-        return array_subscript_simple(self, op);
+    return array_subscript_simple(self, op);
 }
 
 
@@ -2790,43 +2789,43 @@ static int iter_ass_subscript(PyArrayIterObject *, PyObject *, PyObject *);
 static int
 array_ass_sub_simple(PyArrayObject *self, PyObject *index, PyObject *op)
 {
-        int ret;
-        PyArrayObject *tmp;
-        intp value;
+    int ret;
+    PyArrayObject *tmp;
+    intp value;
 
-        value = PyArray_PyIntAsIntp(index);
-        if (!error_converting(value)) {
-                return array_ass_big_item(self, value, op);
-        }
-        PyErr_Clear();
+    value = PyArray_PyIntAsIntp(index);
+    if (!error_converting(value)) {
+        return array_ass_big_item(self, value, op);
+    }
+    PyErr_Clear();
 
-        /* Rest of standard (view-based) indexing */
+    /* Rest of standard (view-based) indexing */
 
-        if (PyArray_CheckExact(self)) {
-                tmp = (PyArrayObject *)array_subscript_simple(self, index);
-                if (tmp == NULL) return -1;
-        }
-        else {
-                PyObject *tmp0;
-                tmp0 = PyObject_GetItem((PyObject *)self, index);
-                if (tmp0 == NULL) return -1;
-                if (!PyArray_Check(tmp0)) {
-                        PyErr_SetString(PyExc_RuntimeError,
-                                        "Getitem not returning array.");
-                        Py_DECREF(tmp0);
-                        return -1;
-                }
-                tmp = (PyArrayObject *)tmp0;
-        }
+    if (PyArray_CheckExact(self)) {
+        tmp = (PyArrayObject *)array_subscript_simple(self, index);
+        if (tmp == NULL) return -1;
+    }
+    else {
+        PyObject *tmp0;
+        tmp0 = PyObject_GetItem((PyObject *)self, index);
+        if (tmp0 == NULL) return -1;
+        if (!PyArray_Check(tmp0)) {
+            PyErr_SetString(PyExc_RuntimeError,
+                            "Getitem not returning array.");
+            Py_DECREF(tmp0);
+            return -1;
+        }
+        tmp = (PyArrayObject *)tmp0;
+    }
 
-        if (PyArray_ISOBJECT(self) && (tmp->nd == 0)) {
-                ret = tmp->descr->f->setitem(op, tmp->data, tmp);
-        }
-        else {
-                ret = PyArray_CopyObject(tmp, op);
-        }
-        Py_DECREF(tmp);
-        return ret;
+    if (PyArray_ISOBJECT(self) && (tmp->nd == 0)) {
+        ret = tmp->descr->f->setitem(op, tmp->data, tmp);
+    }
+    else {
+        ret = PyArray_CopyObject(tmp, op);
+    }
+    Py_DECREF(tmp);
+    return ret;
 }
 
 
@@ -2836,150 +2835,150 @@ array_ass_sub_simple(PyArrayObject *self, PyObject *index, PyObject *op)
 static int
 _tuple_of_integers(PyObject *seq, intp *vals, int maxvals)
 {
-        int i;
-        PyObject *obj;
-        intp temp;
-
-        for (i=0; i<maxvals; i++) {
-                obj = PyTuple_GET_ITEM(seq, i);
-                if ((PyArray_Check(obj) && PyArray_NDIM(obj) > 0) ||
-                    PyList_Check(obj)) return -1;
-                temp = PyArray_PyIntAsIntp(obj);
-                if (error_converting(temp)) return -1;
-                vals[i] = temp;
-        }
-        return 0;
+    int i;
+    PyObject *obj;
+    intp temp;
+
+    for (i=0; i<maxvals; i++) {
+        obj = PyTuple_GET_ITEM(seq, i);
+        if ((PyArray_Check(obj) && PyArray_NDIM(obj) > 0) ||
+            PyList_Check(obj)) return -1;
+        temp = PyArray_PyIntAsIntp(obj);
+        if (error_converting(temp)) return -1;
+        vals[i] = temp;
+    }
+    return 0;
 }
 
 
 static int
 array_ass_sub(PyArrayObject *self, PyObject *index, PyObject *op)
 {
-        int ret, oned, fancy;
-        PyArrayMapIterObject *mit;
-        intp vals[MAX_DIMS];
-
-        if (op == NULL) {
-                PyErr_SetString(PyExc_ValueError,
-                                "cannot delete array elements");
-                return -1;
-        }
-        if (!PyArray_ISWRITEABLE(self)) {
-                PyErr_SetString(PyExc_RuntimeError,
-                                "array is not writeable");
-                return -1;
-        }
+    int ret, oned, fancy;
+    PyArrayMapIterObject *mit;
+    intp vals[MAX_DIMS];
 
-        if (PyInt_Check(index) || PyArray_IsScalar(index, Integer) ||
-            PyLong_Check(index) || (PyIndex_Check(index) && 
-                                    !PySequence_Check(index))) {
-                intp value;
-                value = PyArray_PyIntAsIntp(index);
-                if (PyErr_Occurred())
-                        PyErr_Clear();
-                else
-                        return array_ass_big_item(self, value, op);
-        }
-
-        if (PyString_Check(index) || PyUnicode_Check(index)) {
-                if (self->descr->names) {
-                        PyObject *obj;
-                        obj = PyDict_GetItem(self->descr->fields, index);
-                        if (obj != NULL) {
-                                PyArray_Descr *descr;
-                                int offset;
-                                PyObject *title;
-
-                                if (PyArg_ParseTuple(obj, "Oi|O",
-                                                     &descr, &offset, &title)) {
-                                        Py_INCREF(descr);
-                                        return PyArray_SetField(self, descr,
-                                                                offset, op);
-                                }
-                        }
-                }
+    if (op == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+                        "cannot delete array elements");
+        return -1;
+    }
+    if (!PyArray_ISWRITEABLE(self)) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "array is not writeable");
+        return -1;
+    }
 
-                PyErr_Format(PyExc_ValueError,
-                             "field named %s not found.",
-                             PyString_AsString(index));
-                return -1;
-        }
+    if (PyInt_Check(index) || PyArray_IsScalar(index, Integer) ||
+        PyLong_Check(index) || (PyIndex_Check(index) &&
+                                !PySequence_Check(index))) {
+        intp value;
+        value = PyArray_PyIntAsIntp(index);
+        if (PyErr_Occurred())
+            PyErr_Clear();
+        else
+            return array_ass_big_item(self, value, op);
+    }
 
-        if (self->nd == 0) {
-                /* Several different exceptions to the 0-d no-indexing rule
+    if (PyString_Check(index) || PyUnicode_Check(index)) {
+        if (self->descr->names) {
+            PyObject *obj;
+            obj = PyDict_GetItem(self->descr->fields, index);
+            if (obj != NULL) {
+                PyArray_Descr *descr;
+                int offset;
+                PyObject *title;
 
-                   1) ellipses
-                   2) empty tuple
-                   3) Using newaxis (None)
-                   4) Boolean mask indexing
-                */
-                if (index == Py_Ellipsis || index == Py_None ||         \
-                    (PyTuple_Check(index) && (0 == PyTuple_GET_SIZE(index) || \
-                                              count_new_axes_0d(index) > 0)))
-                        return self->descr->f->setitem(op, self->data, self);
-                if (PyBool_Check(index) || PyArray_IsScalar(index, Bool) ||
-                    (PyArray_Check(index) && (PyArray_DIMS(index)==0) &&
-                     PyArray_ISBOOL(index))) {
-                        if (PyObject_IsTrue(index)) {
-                                return self->descr->f->setitem(op, self->data, self);
-                        }
-                        else { /* don't do anything */
-                                return 0;
-                        }
+                if (PyArg_ParseTuple(obj, "Oi|O",
+                                     &descr, &offset, &title)) {
+                    Py_INCREF(descr);
+                    return PyArray_SetField(self, descr,
+                                            offset, op);
                 }
-                PyErr_SetString(PyExc_IndexError,
-                                "0-d arrays can't be indexed.");
-                return -1;
+            }
         }
-        
-        /* optimization for integer-tuple */
-        if (self->nd > 1 &&
-            (PyTuple_Check(index) && (PyTuple_GET_SIZE(index) == self->nd)) 
-            && (_tuple_of_integers(index, vals, self->nd) >= 0)) {
-                int i;
-                char *item;
-                for (i=0; i<self->nd; i++) {
-                        if (vals[i] < 0) vals[i] += self->dimensions[i];
-                        if ((vals[i] < 0) || (vals[i] >= self->dimensions[i])) {
-                                PyErr_Format(PyExc_IndexError,
-                                             "index (%"INTP_FMT") out of range "\
-                                             "(0<=index<%"INTP_FMT") in dimension %d",
-                                             vals[i], self->dimensions[i], i);
-                                return -1;
-                        }
-                }
-                item = PyArray_GetPtr(self, vals);
-                /* fprintf(stderr, "Here I am...\n");*/
-                return self->descr->f->setitem(op, item, self);
+
+        PyErr_Format(PyExc_ValueError,
+                     "field named %s not found.",
+                     PyString_AsString(index));
+        return -1;
+    }
+
+    if (self->nd == 0) {
+        /* Several different exceptions to the 0-d no-indexing rule
+
+           1) ellipses
+           2) empty tuple
+           3) Using newaxis (None)
+           4) Boolean mask indexing
+        */
+        if (index == Py_Ellipsis || index == Py_None ||         \
+            (PyTuple_Check(index) && (0 == PyTuple_GET_SIZE(index) || \
+                                      count_new_axes_0d(index) > 0)))
+            return self->descr->f->setitem(op, self->data, self);
+        if (PyBool_Check(index) || PyArray_IsScalar(index, Bool) ||
+            (PyArray_Check(index) && (PyArray_DIMS(index)==0) &&
+             PyArray_ISBOOL(index))) {
+            if (PyObject_IsTrue(index)) {
+                return self->descr->f->setitem(op, self->data, self);
+            }
+            else { /* don't do anything */
+                return 0;
+            }
         }
-        PyErr_Clear();
+        PyErr_SetString(PyExc_IndexError,
+                        "0-d arrays can't be indexed.");
+        return -1;
+    }
 
-        fancy = fancy_indexing_check(index);
-
-        if (fancy != SOBJ_NOTFANCY) {
-                oned = ((self->nd == 1) &&
-                        !(PyTuple_Check(index) && PyTuple_GET_SIZE(index) > 1));
-
-                mit = (PyArrayMapIterObject *)                  \
-                        PyArray_MapIterNew(index, oned, fancy);
-                if (mit == NULL) return -1;
-                if (oned) {
-                        PyArrayIterObject *it;
-                        int rval;
-                        it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self);
-                        if (it == NULL) {Py_DECREF(mit); return -1;}
-                        rval = iter_ass_subscript(it, mit->indexobj, op);
-                        Py_DECREF(it);
-                        Py_DECREF(mit);
-                        return rval;
-                }
-                PyArray_MapIterBind(mit, self);
-                ret = PyArray_SetMap(mit, op);
-                Py_DECREF(mit);
-                return ret;
+    /* optimization for integer-tuple */
+    if (self->nd > 1 &&
+        (PyTuple_Check(index) && (PyTuple_GET_SIZE(index) == self->nd))
+        && (_tuple_of_integers(index, vals, self->nd) >= 0)) {
+        int i;
+        char *item;
+        for (i=0; i<self->nd; i++) {
+            if (vals[i] < 0) vals[i] += self->dimensions[i];
+            if ((vals[i] < 0) || (vals[i] >= self->dimensions[i])) {
+                PyErr_Format(PyExc_IndexError,
+                             "index (%"INTP_FMT") out of range "\
+                             "(0<=index<%"INTP_FMT") in dimension %d",
+                             vals[i], self->dimensions[i], i);
+                return -1;
+            }
         }
+        item = PyArray_GetPtr(self, vals);
+        /* fprintf(stderr, "Here I am...\n");*/
+        return self->descr->f->setitem(op, item, self);
+    }
+    PyErr_Clear();
+
+    fancy = fancy_indexing_check(index);
+
+    if (fancy != SOBJ_NOTFANCY) {
+        oned = ((self->nd == 1) &&
+                !(PyTuple_Check(index) && PyTuple_GET_SIZE(index) > 1));
+
+        mit = (PyArrayMapIterObject *)                  \
+            PyArray_MapIterNew(index, oned, fancy);
+        if (mit == NULL) return -1;
+        if (oned) {
+            PyArrayIterObject *it;
+            int rval;
+            it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self);
+            if (it == NULL) {Py_DECREF(mit); return -1;}
+            rval = iter_ass_subscript(it, mit->indexobj, op);
+            Py_DECREF(it);
+            Py_DECREF(mit);
+            return rval;
+        }
+        PyArray_MapIterBind(mit, self);
+        ret = PyArray_SetMap(mit, op);
+        Py_DECREF(mit);
+        return ret;
+    }
 
-        return array_ass_sub_simple(self, index, op);
+    return array_ass_sub_simple(self, index, op);
 }
 
 
@@ -2993,94 +2992,94 @@ static PyObject *
 array_subscript_nice(PyArrayObject *self, PyObject *op)
 {
 
-        PyArrayObject *mp;
-        intp vals[MAX_DIMS];
+    PyArrayObject *mp;
+    intp vals[MAX_DIMS];
 
-        if (PyInt_Check(op) || PyArray_IsScalar(op, Integer) || \
-            PyLong_Check(op) || (PyIndex_Check(op) && 
-                                 !PySequence_Check(op))) {
-                intp value;
-                value = PyArray_PyIntAsIntp(op);
-                if (PyErr_Occurred())
-                        PyErr_Clear();
-                else {
-                        return array_item_nice(self, (Py_ssize_t) value);
-                }
+    if (PyInt_Check(op) || PyArray_IsScalar(op, Integer) || \
+        PyLong_Check(op) || (PyIndex_Check(op) &&
+                             !PySequence_Check(op))) {
+        intp value;
+        value = PyArray_PyIntAsIntp(op);
+        if (PyErr_Occurred())
+            PyErr_Clear();
+        else {
+            return array_item_nice(self, (Py_ssize_t) value);
         }
-        /* optimization for a tuple of integers */
-        if (self->nd > 1 && PyTuple_Check(op) &&
-            (PyTuple_GET_SIZE(op) == self->nd)
-            && (_tuple_of_integers(op, vals, self->nd) >= 0)) {
-                int i;
-                char *item;
-                for (i=0; i<self->nd; i++) {
-                        if (vals[i] < 0) vals[i] += self->dimensions[i];
-                        if ((vals[i] < 0) || (vals[i] >= self->dimensions[i])) {
-                                PyErr_Format(PyExc_IndexError,
-                                             "index (%"INTP_FMT") out of range "\
-                                             "(0<=index<=%"INTP_FMT") in dimension %d",
-                                             vals[i], self->dimensions[i], i);
-                                return NULL;
-                        }
-                }
-                item = PyArray_GetPtr(self, vals);
-                return PyArray_Scalar(item, self->descr, (PyObject *)self);
+    }
+    /* optimization for a tuple of integers */
+    if (self->nd > 1 && PyTuple_Check(op) &&
+        (PyTuple_GET_SIZE(op) == self->nd)
+        && (_tuple_of_integers(op, vals, self->nd) >= 0)) {
+        int i;
+        char *item;
+        for (i=0; i<self->nd; i++) {
+            if (vals[i] < 0) vals[i] += self->dimensions[i];
+            if ((vals[i] < 0) || (vals[i] >= self->dimensions[i])) {
+                PyErr_Format(PyExc_IndexError,
+                             "index (%"INTP_FMT") out of range "\
+                             "(0<=index<=%"INTP_FMT") in dimension %d",
+                             vals[i], self->dimensions[i], i);
+                return NULL;
+            }
         }
-        PyErr_Clear();
+        item = PyArray_GetPtr(self, vals);
+        return PyArray_Scalar(item, self->descr, (PyObject *)self);
+    }
+    PyErr_Clear();
 
-        mp = (PyArrayObject *)array_subscript(self, op);
+    mp = (PyArrayObject *)array_subscript(self, op);
 
-        /* The following is just a copy of PyArray_Return with an
-           additional logic in the nd == 0 case.
-        */
+    /* The following is just a copy of PyArray_Return with an
+       additional logic in the nd == 0 case.
+    */
 
-        if (mp == NULL) return NULL;
+    if (mp == NULL) return NULL;
 
-        if (PyErr_Occurred()) {
-                Py_XDECREF(mp);
-                return NULL;
-        }
+    if (PyErr_Occurred()) {
+        Py_XDECREF(mp);
+        return NULL;
+    }
 
-        if (mp->nd == 0) {
-                Bool noellipses = TRUE;
-                if ((op == Py_Ellipsis) || PyString_Check(op) || PyUnicode_Check(op))
-                        noellipses = FALSE;
-                else if (PyBool_Check(op) || PyArray_IsScalar(op, Bool) || 
-                         (PyArray_Check(op) && (PyArray_DIMS(op)==0) &&
-                          PyArray_ISBOOL(op))) 
-                        noellipses = FALSE;
-                else if (PySequence_Check(op)) {
-                        int n, i;
-                        PyObject *temp;
-                        n = PySequence_Size(op);
-                        i=0;
-                        while (i<n && noellipses) {
-                                temp = PySequence_GetItem(op, i);
-                                if (temp == Py_Ellipsis)
-                                        noellipses = FALSE;
-                                Py_DECREF(temp);
-                                i++;
-                        }
-                }
-                if (noellipses) {
-                        PyObject *ret;
-                        ret = PyArray_ToScalar(mp->data, mp);
-                        Py_DECREF(mp);
-                        return ret;
-                }
+    if (mp->nd == 0) {
+        Bool noellipses = TRUE;
+        if ((op == Py_Ellipsis) || PyString_Check(op) || PyUnicode_Check(op))
+            noellipses = FALSE;
+        else if (PyBool_Check(op) || PyArray_IsScalar(op, Bool) ||
+                 (PyArray_Check(op) && (PyArray_DIMS(op)==0) &&
+                  PyArray_ISBOOL(op)))
+            noellipses = FALSE;
+        else if (PySequence_Check(op)) {
+            int n, i;
+            PyObject *temp;
+            n = PySequence_Size(op);
+            i=0;
+            while (i<n && noellipses) {
+                temp = PySequence_GetItem(op, i);
+                if (temp == Py_Ellipsis)
+                    noellipses = FALSE;
+                Py_DECREF(temp);
+                i++;
+            }
         }
-        return (PyObject *)mp;
+        if (noellipses) {
+            PyObject *ret;
+            ret = PyArray_ToScalar(mp->data, mp);
+            Py_DECREF(mp);
+            return ret;
+        }
+    }
+    return (PyObject *)mp;
 }
 
 
 static PyMappingMethods array_as_mapping = {
 #if PY_VERSION_HEX >= 0x02050000
-        (lenfunc)array_length,              /*mp_length*/
+    (lenfunc)array_length,              /*mp_length*/
 #else
-        (inquiry)array_length,              /*mp_length*/
+    (inquiry)array_length,              /*mp_length*/
 #endif
-        (binaryfunc)array_subscript_nice,       /*mp_subscript*/
-        (objobjargproc)array_ass_sub,       /*mp_ass_subscript*/
+    (binaryfunc)array_subscript_nice,       /*mp_subscript*/
+    (objobjargproc)array_ass_sub,       /*mp_ass_subscript*/
 };
 
 /****************** End of Mapping Protocol ******************************/
@@ -3095,75 +3094,75 @@ static PyMappingMethods array_as_mapping = {
 static Py_ssize_t
 array_getsegcount(PyArrayObject *self, Py_ssize_t *lenp)
 {
-        if (lenp)
-                *lenp = PyArray_NBYTES(self);
+    if (lenp)
+        *lenp = PyArray_NBYTES(self);
 
-        if (PyArray_ISONESEGMENT(self)) {
-                return 1;
-        }
+    if (PyArray_ISONESEGMENT(self)) {
+        return 1;
+    }
 
-        if (lenp)
-                *lenp = 0;
-        return 0;
+    if (lenp)
+        *lenp = 0;
+    return 0;
 }
 
 static Py_ssize_t
 array_getreadbuf(PyArrayObject *self, Py_ssize_t segment, void **ptrptr)
 {
-        if (segment != 0) {
-                PyErr_SetString(PyExc_ValueError,
-                                "accessing non-existing array segment");
-                return -1;
-        }
-
-        if (PyArray_ISONESEGMENT(self)) {
-                *ptrptr = self->data;
-                return PyArray_NBYTES(self);
-        }
-        PyErr_SetString(PyExc_ValueError, "array is not a single segment");
-        *ptrptr = NULL;
+    if (segment != 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "accessing non-existing array segment");
         return -1;
+    }
+
+    if (PyArray_ISONESEGMENT(self)) {
+        *ptrptr = self->data;
+        return PyArray_NBYTES(self);
+    }
+    PyErr_SetString(PyExc_ValueError, "array is not a single segment");
+    *ptrptr = NULL;
+    return -1;
 }
 
 
 static Py_ssize_t
 array_getwritebuf(PyArrayObject *self, Py_ssize_t segment, void **ptrptr)
 {
-        if (PyArray_CHKFLAGS(self, WRITEABLE))
-                return array_getreadbuf(self, segment, (void **) ptrptr);
-        else {
-                PyErr_SetString(PyExc_ValueError, "array cannot be "\
-                                "accessed as a writeable buffer");
-                return -1;
-        }
+    if (PyArray_CHKFLAGS(self, WRITEABLE))
+        return array_getreadbuf(self, segment, (void **) ptrptr);
+    else {
+        PyErr_SetString(PyExc_ValueError, "array cannot be "\
+                        "accessed as a writeable buffer");
+        return -1;
+    }
 }
 
 static Py_ssize_t
 array_getcharbuf(PyArrayObject *self, Py_ssize_t segment, constchar **ptrptr)
 {
-        if (self->descr->type_num == PyArray_STRING || \
-            self->descr->type_num == PyArray_UNICODE || \
-            self->descr->elsize == 1)
-                return array_getreadbuf(self, segment, (void **) ptrptr);
-        else {
-                PyErr_SetString(PyExc_TypeError,
-                                "non-character (or 8-bit) array cannot be "\
-                                "interpreted as character buffer");
-                return -1;
-        }
+    if (self->descr->type_num == PyArray_STRING || \
+        self->descr->type_num == PyArray_UNICODE || \
+        self->descr->elsize == 1)
+        return array_getreadbuf(self, segment, (void **) ptrptr);
+    else {
+        PyErr_SetString(PyExc_TypeError,
+                        "non-character (or 8-bit) array cannot be "\
+                        "interpreted as character buffer");
+        return -1;
+    }
 }
 
 static PyBufferProcs array_as_buffer = {
 #if PY_VERSION_HEX >= 0x02050000
-        (readbufferproc)array_getreadbuf,    /*bf_getreadbuffer*/
-        (writebufferproc)array_getwritebuf,  /*bf_getwritebuffer*/
-        (segcountproc)array_getsegcount,            /*bf_getsegcount*/
-        (charbufferproc)array_getcharbuf,    /*bf_getcharbuffer*/
+    (readbufferproc)array_getreadbuf,    /*bf_getreadbuffer*/
+    (writebufferproc)array_getwritebuf,  /*bf_getwritebuffer*/
+    (segcountproc)array_getsegcount,            /*bf_getsegcount*/
+    (charbufferproc)array_getcharbuf,    /*bf_getcharbuffer*/
 #else
-        (getreadbufferproc)array_getreadbuf,    /*bf_getreadbuffer*/
-        (getwritebufferproc)array_getwritebuf,  /*bf_getwritebuffer*/
-        (getsegcountproc)array_getsegcount,         /*bf_getsegcount*/
-        (getcharbufferproc)array_getcharbuf,    /*bf_getcharbuffer*/
+    (getreadbufferproc)array_getreadbuf,    /*bf_getreadbuffer*/
+    (getwritebufferproc)array_getwritebuf,  /*bf_getwritebuffer*/
+    (getsegcountproc)array_getsegcount,         /*bf_getsegcount*/
+    (getcharbufferproc)array_getcharbuf,    /*bf_getcharbuffer*/
 #endif
 };
 
@@ -3176,197 +3175,197 @@ static PyBufferProcs array_as_buffer = {
 
 
 typedef struct {
-        PyObject *add,
-                *subtract,
-                *multiply,
-                *divide,
-                *remainder,
-                *power,
-                *square,
-                *reciprocal,
-                *ones_like,
-                *sqrt,
-                *negative,
-                *absolute,
-                *invert,
-                *left_shift,
-                *right_shift,
-                *bitwise_and,
-                *bitwise_xor,
-                *bitwise_or,
-                *less,
-                *less_equal,
-                *equal,
-                *not_equal,
-                *greater,
-                *greater_equal,
-                *floor_divide,
-                *true_divide,
-                *logical_or,
-                *logical_and,
-                *floor,
-                *ceil,
-                *maximum,
-                *minimum,
-                *rint,
-                *conjugate;
+    PyObject *add,
+        *subtract,
+        *multiply,
+        *divide,
+        *remainder,
+        *power,
+        *square,
+        *reciprocal,
+        *ones_like,
+        *sqrt,
+        *negative,
+        *absolute,
+        *invert,
+        *left_shift,
+        *right_shift,
+        *bitwise_and,
+        *bitwise_xor,
+        *bitwise_or,
+        *less,
+        *less_equal,
+        *equal,
+        *not_equal,
+        *greater,
+        *greater_equal,
+        *floor_divide,
+        *true_divide,
+        *logical_or,
+        *logical_and,
+        *floor,
+        *ceil,
+        *maximum,
+        *minimum,
+        *rint,
+        *conjugate;
 } NumericOps;
 
 static NumericOps n_ops; /* NB: static objects inlitialized to zero */
 
 /* Dictionary can contain any of the numeric operations, by name.
-  Those not present will not be changed
- */
+   Those not present will not be changed
+*/
 
 #define SET(op)   temp=PyDict_GetItemString(dict, #op); \
-        if (temp != NULL) {                             \
-                if (!(PyCallable_Check(temp))) return -1; \
-                Py_XDECREF(n_ops.op); \
-                n_ops.op = temp; \
-        }
+    if (temp != NULL) {                                 \
+        if (!(PyCallable_Check(temp))) return -1;       \
+        Py_XDECREF(n_ops.op);                           \
+        n_ops.op = temp;                                \
+    }
 
 
 /*OBJECT_API
- Set internal structure with number functions that all arrays will use
+  Set internal structure with number functions that all arrays will use
 */
 int
 PyArray_SetNumericOps(PyObject *dict)
 {
-        PyObject *temp = NULL;
-        SET(add);
-        SET(subtract);
-        SET(multiply);
-        SET(divide);
-        SET(remainder);
-        SET(power);
-        SET(square);
-        SET(reciprocal);
-        SET(ones_like);
-        SET(sqrt);
-        SET(negative);
-        SET(absolute);
-        SET(invert);
-        SET(left_shift);
-        SET(right_shift);
-        SET(bitwise_and);
-        SET(bitwise_or);
-        SET(bitwise_xor);
-        SET(less);
-        SET(less_equal);
-        SET(equal);
-        SET(not_equal);
-        SET(greater);
-        SET(greater_equal);
-        SET(floor_divide);
-        SET(true_divide);
-        SET(logical_or);
-        SET(logical_and);
-        SET(floor);
-        SET(ceil);
-        SET(maximum);
-        SET(minimum);
-        SET(rint);
-        SET(conjugate);
-        return 0;
+    PyObject *temp = NULL;
+    SET(add);
+    SET(subtract);
+    SET(multiply);
+    SET(divide);
+    SET(remainder);
+    SET(power);
+    SET(square);
+    SET(reciprocal);
+    SET(ones_like);
+    SET(sqrt);
+    SET(negative);
+    SET(absolute);
+    SET(invert);
+    SET(left_shift);
+    SET(right_shift);
+    SET(bitwise_and);
+    SET(bitwise_or);
+    SET(bitwise_xor);
+    SET(less);
+    SET(less_equal);
+    SET(equal);
+    SET(not_equal);
+    SET(greater);
+    SET(greater_equal);
+    SET(floor_divide);
+    SET(true_divide);
+    SET(logical_or);
+    SET(logical_and);
+    SET(floor);
+    SET(ceil);
+    SET(maximum);
+    SET(minimum);
+    SET(rint);
+    SET(conjugate);
+    return 0;
 }
 
 #define GET(op) if (n_ops.op &&                                         \
                     (PyDict_SetItemString(dict, #op, n_ops.op)==-1))    \
-                goto fail;
+        goto fail;
 
 /*OBJECT_API
- Get dictionary showing number functions that all arrays will use
+  Get dictionary showing number functions that all arrays will use
 */
 static PyObject *
 PyArray_GetNumericOps(void)
 {
-        PyObject *dict;
-        if ((dict = PyDict_New())==NULL)
-                return NULL;
-        GET(add);
-        GET(subtract);
-        GET(multiply);
-        GET(divide);
-        GET(remainder);
-        GET(power);
-        GET(square);
-        GET(reciprocal);
-        GET(ones_like);
-        GET(sqrt);
-        GET(negative);
-        GET(absolute);
-        GET(invert);
-        GET(left_shift);
-        GET(right_shift);
-        GET(bitwise_and);
-        GET(bitwise_or);
-        GET(bitwise_xor);
-        GET(less);
-        GET(less_equal);
-        GET(equal);
-        GET(not_equal);
-        GET(greater);
-        GET(greater_equal);
-        GET(floor_divide);
-        GET(true_divide);
-        GET(logical_or);
-        GET(logical_and);
-        GET(floor);
-        GET(ceil);
-        GET(maximum);
-        GET(minimum);
-        GET(rint);
-        GET(conjugate);
-        return dict;
+    PyObject *dict;
+    if ((dict = PyDict_New())==NULL)
+        return NULL;
+    GET(add);
+    GET(subtract);
+    GET(multiply);
+    GET(divide);
+    GET(remainder);
+    GET(power);
+    GET(square);
+    GET(reciprocal);
+    GET(ones_like);
+    GET(sqrt);
+    GET(negative);
+    GET(absolute);
+    GET(invert);
+    GET(left_shift);
+    GET(right_shift);
+    GET(bitwise_and);
+    GET(bitwise_or);
+    GET(bitwise_xor);
+    GET(less);
+    GET(less_equal);
+    GET(equal);
+    GET(not_equal);
+    GET(greater);
+    GET(greater_equal);
+    GET(floor_divide);
+    GET(true_divide);
+    GET(logical_or);
+    GET(logical_and);
+    GET(floor);
+    GET(ceil);
+    GET(maximum);
+    GET(minimum);
+    GET(rint);
+    GET(conjugate);
+    return dict;
 
  fail:
-        Py_DECREF(dict);
-        return NULL;
+    Py_DECREF(dict);
+    return NULL;
 }
 
 static PyObject *
 _get_keywords(int rtype, PyArrayObject *out)
 {
-        PyObject *kwds=NULL;
-        if (rtype != PyArray_NOTYPE || out != NULL) {
-                kwds = PyDict_New();
-                if (rtype != PyArray_NOTYPE) {
-                        PyArray_Descr *descr;
-                        descr = PyArray_DescrFromType(rtype);
-                        if (descr) {
-                                PyDict_SetItemString(kwds, "dtype",
-                                                     (PyObject *)descr);
-                                Py_DECREF(descr);
-                        }
-                }
-                if (out != NULL) {
-                        PyDict_SetItemString(kwds, "out",
-                                             (PyObject *)out);
-                }
+    PyObject *kwds=NULL;
+    if (rtype != PyArray_NOTYPE || out != NULL) {
+        kwds = PyDict_New();
+        if (rtype != PyArray_NOTYPE) {
+            PyArray_Descr *descr;
+            descr = PyArray_DescrFromType(rtype);
+            if (descr) {
+                PyDict_SetItemString(kwds, "dtype",
+                                     (PyObject *)descr);
+                Py_DECREF(descr);
+            }
+        }
+        if (out != NULL) {
+            PyDict_SetItemString(kwds, "out",
+                                 (PyObject *)out);
         }
-        return kwds;
+    }
+    return kwds;
 }
 
 static PyObject *
 PyArray_GenericReduceFunction(PyArrayObject *m1, PyObject *op, int axis,
                               int rtype, PyArrayObject *out)
 {
-        PyObject *args, *ret=NULL, *meth;
-        PyObject *kwds;
-        if (op == NULL) {
-                Py_INCREF(Py_NotImplemented);
-                return Py_NotImplemented;
-        }
-        args = Py_BuildValue("(Oi)", m1, axis);
-        kwds = _get_keywords(rtype, out);
-        meth = PyObject_GetAttrString(op, "reduce");
-        if (meth && PyCallable_Check(meth)) {
-                ret = PyObject_Call(meth, args, kwds);
-        }
-        Py_DECREF(args);
-        Py_DECREF(meth);
-        Py_XDECREF(kwds);
-        return ret;
+    PyObject *args, *ret=NULL, *meth;
+    PyObject *kwds;
+    if (op == NULL) {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+    args = Py_BuildValue("(Oi)", m1, axis);
+    kwds = _get_keywords(rtype, out);
+    meth = PyObject_GetAttrString(op, "reduce");
+    if (meth && PyCallable_Check(meth)) {
+        ret = PyObject_Call(meth, args, kwds);
+    }
+    Py_DECREF(args);
+    Py_DECREF(meth);
+    Py_XDECREF(kwds);
+    return ret;
 }
 
 
@@ -3374,94 +3373,94 @@ static PyObject *
 PyArray_GenericAccumulateFunction(PyArrayObject *m1, PyObject *op, int axis,
                                   int rtype, PyArrayObject *out)
 {
-        PyObject *args, *ret=NULL, *meth;
-        PyObject *kwds;
-        if (op == NULL) {
-                Py_INCREF(Py_NotImplemented);
-                return Py_NotImplemented;
-        }
-        args = Py_BuildValue("(Oi)", m1, axis);
-        kwds = _get_keywords(rtype, out);
-        meth = PyObject_GetAttrString(op, "accumulate");
-        if (meth && PyCallable_Check(meth)) {
-                ret = PyObject_Call(meth, args, kwds);
-        }
-        Py_DECREF(args);
-        Py_DECREF(meth);
-        Py_XDECREF(kwds);
-        return ret;
+    PyObject *args, *ret=NULL, *meth;
+    PyObject *kwds;
+    if (op == NULL) {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+    args = Py_BuildValue("(Oi)", m1, axis);
+    kwds = _get_keywords(rtype, out);
+    meth = PyObject_GetAttrString(op, "accumulate");
+    if (meth && PyCallable_Check(meth)) {
+        ret = PyObject_Call(meth, args, kwds);
+    }
+    Py_DECREF(args);
+    Py_DECREF(meth);
+    Py_XDECREF(kwds);
+    return ret;
 }
 
 
 static PyObject *
 PyArray_GenericBinaryFunction(PyArrayObject *m1, PyObject *m2, PyObject *op)
 {
-        if (op == NULL) {
-                Py_INCREF(Py_NotImplemented);
-                return Py_NotImplemented;
-        }
-        return PyObject_CallFunction(op, "OO", m1, m2);
+    if (op == NULL) {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+    return PyObject_CallFunction(op, "OO", m1, m2);
 }
 
 static PyObject *
 PyArray_GenericUnaryFunction(PyArrayObject *m1, PyObject *op)
 {
-        if (op == NULL) {
-                Py_INCREF(Py_NotImplemented);
-                return Py_NotImplemented;
-        }
-        return PyObject_CallFunction(op, "(O)", m1);
+    if (op == NULL) {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+    return PyObject_CallFunction(op, "(O)", m1);
 }
 
 static PyObject *
 PyArray_GenericInplaceBinaryFunction(PyArrayObject *m1,
                                      PyObject *m2, PyObject *op)
 {
-        if (op == NULL) {
-                Py_INCREF(Py_NotImplemented);
-                return Py_NotImplemented;
-        }
-        return PyObject_CallFunction(op, "OOO", m1, m2, m1);
+    if (op == NULL) {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+    return PyObject_CallFunction(op, "OOO", m1, m2, m1);
 }
 
 static PyObject *
 PyArray_GenericInplaceUnaryFunction(PyArrayObject *m1, PyObject *op)
 {
-        if (op == NULL) {
-                Py_INCREF(Py_NotImplemented);
-                return Py_NotImplemented;
-        }
-        return PyObject_CallFunction(op, "OO", m1, m1);
+    if (op == NULL) {
+        Py_INCREF(Py_NotImplemented);
+        return Py_NotImplemented;
+    }
+    return PyObject_CallFunction(op, "OO", m1, m1);
 }
 
 static PyObject *
 array_add(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.add);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.add);
 }
 
 static PyObject *
 array_subtract(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.subtract);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.subtract);
 }
 
 static PyObject *
 array_multiply(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.multiply);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.multiply);
 }
 
 static PyObject *
 array_divide(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.divide);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.divide);
 }
 
 static PyObject *
 array_remainder(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.remainder);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.remainder);
 }
 
 static int
@@ -3471,41 +3470,41 @@ array_power_is_scalar(PyObject *o2, double* exp)
     const int optimize_fpexps = 1;
 
     if (PyInt_Check(o2)) {
-            *exp = (double)PyInt_AsLong(o2);
-            return 1;
+        *exp = (double)PyInt_AsLong(o2);
+        return 1;
     }
     if (optimize_fpexps && PyFloat_Check(o2)) {
-            *exp = PyFloat_AsDouble(o2);
-            return 1;
+        *exp = PyFloat_AsDouble(o2);
+        return 1;
     }
     if ((PyArray_IsZeroDim(o2) &&
          ((PyArray_ISINTEGER(o2) ||
            (optimize_fpexps && PyArray_ISFLOAT(o2))))) ||
         PyArray_IsScalar(o2, Integer) ||
         (optimize_fpexps && PyArray_IsScalar(o2, Floating))) {
-            temp = o2->ob_type->tp_as_number->nb_float(o2);
-            if (temp != NULL) {
-                    *exp = PyFloat_AsDouble(o2);
-                    Py_DECREF(temp);
-                    return 1;
-            }
+        temp = o2->ob_type->tp_as_number->nb_float(o2);
+        if (temp != NULL) {
+            *exp = PyFloat_AsDouble(o2);
+            Py_DECREF(temp);
+            return 1;
+        }
     }
 #if (PY_VERSION_HEX >= 0x02050000)
     if (PyIndex_Check(o2)) {
-            PyObject* value = PyNumber_Index(o2);
-            Py_ssize_t val;
-	    if (value==NULL) {
-	      if (PyErr_Occurred())
-		PyErr_Clear();
-	      return 0;
-	    }
-            val = PyInt_AsSsize_t(value);
-            if (val == -1 && PyErr_Occurred()) {
-                    PyErr_Clear();
-                    return 0;
-            }
-            *exp = (double) val;
-            return 1;
+        PyObject* value = PyNumber_Index(o2);
+        Py_ssize_t val;
+        if (value==NULL) {
+            if (PyErr_Occurred())
+                PyErr_Clear();
+            return 0;
+        }
+        val = PyInt_AsSsize_t(value);
+        if (val == -1 && PyErr_Occurred()) {
+            PyErr_Clear();
+            return 0;
+        }
+        *exp = (double) val;
+        return 1;
     }
 #endif
     return 0;
@@ -3514,145 +3513,145 @@ array_power_is_scalar(PyObject *o2, double* exp)
 /* optimize float array or complex array to a scalar power */
 static PyObject *
 fast_scalar_power(PyArrayObject *a1, PyObject *o2, int inplace) {
-        double exp;
-        if (PyArray_Check(a1) && array_power_is_scalar(o2, &exp)) {
-                PyObject *fastop = NULL;
-                if (PyArray_ISFLOAT(a1) || PyArray_ISCOMPLEX(a1)) {
-                        if (exp == 1.0) {
-                                /* we have to do this one special, as the
-                                   "copy" method of array objects isn't set
-                                   up early enough to be added
-                                   by PyArray_SetNumericOps.
-                                */
-                                if (inplace) {
-                                        Py_INCREF(a1);
-                                        return (PyObject *)a1;
-                                } else {
-                                        return PyArray_Copy(a1);
-                                }
-                        } else if (exp == -1.0) {
-                                fastop = n_ops.reciprocal;
-                        } else if (exp ==  0.0) {
-                                fastop = n_ops.ones_like;
-                        } else if (exp ==  0.5) {
-                                fastop = n_ops.sqrt;
-                        } else if (exp ==  2.0) {
-                                fastop = n_ops.square;
-                        } else {
-                                return NULL;
-                        }
-                        if (inplace) {
-                                return PyArray_GenericInplaceUnaryFunction(a1,
-                                                                    fastop);
-                        } else {
-                                return PyArray_GenericUnaryFunction(a1,
-                                                                    fastop);
-                        }
-                }
-                else if (exp==2.0) {
-                        fastop = n_ops.multiply;
-                        if (inplace) {
-                                return PyArray_GenericInplaceBinaryFunction \
-                                        (a1, (PyObject *)a1, fastop);
-                        }
-                        else {
-                                return PyArray_GenericBinaryFunction \
-                                        (a1, (PyObject *)a1, fastop);
-                        }
-                }
+    double exp;
+    if (PyArray_Check(a1) && array_power_is_scalar(o2, &exp)) {
+        PyObject *fastop = NULL;
+        if (PyArray_ISFLOAT(a1) || PyArray_ISCOMPLEX(a1)) {
+            if (exp == 1.0) {
+                /* we have to do this one special, as the
+                   "copy" method of array objects isn't set
+                   up early enough to be added
+                   by PyArray_SetNumericOps.
+                */
+                if (inplace) {
+                    Py_INCREF(a1);
+                    return (PyObject *)a1;
+                } else {
+                    return PyArray_Copy(a1);
+                }
+            } else if (exp == -1.0) {
+                fastop = n_ops.reciprocal;
+            } else if (exp ==  0.0) {
+                fastop = n_ops.ones_like;
+            } else if (exp ==  0.5) {
+                fastop = n_ops.sqrt;
+            } else if (exp ==  2.0) {
+                fastop = n_ops.square;
+            } else {
+                return NULL;
+            }
+            if (inplace) {
+                return PyArray_GenericInplaceUnaryFunction(a1,
+                                                           fastop);
+            } else {
+                return PyArray_GenericUnaryFunction(a1,
+                                                    fastop);
+            }
         }
-        return NULL;
+        else if (exp==2.0) {
+            fastop = n_ops.multiply;
+            if (inplace) {
+                return PyArray_GenericInplaceBinaryFunction \
+                    (a1, (PyObject *)a1, fastop);
+            }
+            else {
+                return PyArray_GenericBinaryFunction \
+                    (a1, (PyObject *)a1, fastop);
+            }
+        }
+    }
+    return NULL;
 }
 
 static PyObject *
 array_power(PyArrayObject *a1, PyObject *o2, PyObject *modulo)
 {
-        /* modulo is ignored! */
-        PyObject *value;
-        value = fast_scalar_power(a1, o2, 0);
-        if (!value) {
-                value = PyArray_GenericBinaryFunction(a1, o2, n_ops.power);
-        }
-        return value;
+    /* modulo is ignored! */
+    PyObject *value;
+    value = fast_scalar_power(a1, o2, 0);
+    if (!value) {
+        value = PyArray_GenericBinaryFunction(a1, o2, n_ops.power);
+    }
+    return value;
 }
 
 
 static PyObject *
 array_negative(PyArrayObject *m1)
 {
-        return PyArray_GenericUnaryFunction(m1, n_ops.negative);
+    return PyArray_GenericUnaryFunction(m1, n_ops.negative);
 }
 
 static PyObject *
 array_absolute(PyArrayObject *m1)
 {
-        return PyArray_GenericUnaryFunction(m1, n_ops.absolute);
+    return PyArray_GenericUnaryFunction(m1, n_ops.absolute);
 }
 
 static PyObject *
 array_invert(PyArrayObject *m1)
 {
-        return PyArray_GenericUnaryFunction(m1, n_ops.invert);
+    return PyArray_GenericUnaryFunction(m1, n_ops.invert);
 }
 
 static PyObject *
 array_left_shift(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.left_shift);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.left_shift);
 }
 
 static PyObject *
 array_right_shift(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.right_shift);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.right_shift);
 }
 
 static PyObject *
 array_bitwise_and(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.bitwise_and);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.bitwise_and);
 }
 
 static PyObject *
 array_bitwise_or(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.bitwise_or);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.bitwise_or);
 }
 
 static PyObject *
 array_bitwise_xor(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.bitwise_xor);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.bitwise_xor);
 }
 
 static PyObject *
 array_inplace_add(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.add);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.add);
 }
 
 static PyObject *
 array_inplace_subtract(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.subtract);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.subtract);
 }
 
 static PyObject *
 array_inplace_multiply(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.multiply);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.multiply);
 }
 
 static PyObject *
 array_inplace_divide(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.divide);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.divide);
 }
 
 static PyObject *
 array_inplace_remainder(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.remainder);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.remainder);
 }
 
 static PyObject *
@@ -3670,99 +3669,99 @@ array_inplace_power(PyArrayObject *a1, PyObject *o2, PyObject *modulo)
 static PyObject *
 array_inplace_left_shift(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.left_shift);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.left_shift);
 }
 
 static PyObject *
 array_inplace_right_shift(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.right_shift);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.right_shift);
 }
 
 static PyObject *
 array_inplace_bitwise_and(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.bitwise_and);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.bitwise_and);
 }
 
 static PyObject *
 array_inplace_bitwise_or(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.bitwise_or);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.bitwise_or);
 }
 
 static PyObject *
 array_inplace_bitwise_xor(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.bitwise_xor);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2, n_ops.bitwise_xor);
 }
 
 static PyObject *
 array_floor_divide(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.floor_divide);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.floor_divide);
 }
 
 static PyObject *
 array_true_divide(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericBinaryFunction(m1, m2, n_ops.true_divide);
+    return PyArray_GenericBinaryFunction(m1, m2, n_ops.true_divide);
 }
 
 static PyObject *
 array_inplace_floor_divide(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2,
-                                                    n_ops.floor_divide);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2,
+                                                n_ops.floor_divide);
 }
 
 static PyObject *
 array_inplace_true_divide(PyArrayObject *m1, PyObject *m2)
 {
-        return PyArray_GenericInplaceBinaryFunction(m1, m2,
-                                                    n_ops.true_divide);
+    return PyArray_GenericInplaceBinaryFunction(m1, m2,
+                                                n_ops.true_divide);
 }
 
 /* Array evaluates as "TRUE" if any of the elements are non-zero*/
 static int
 array_any_nonzero(PyArrayObject *mp)
 {
-        intp index;
-        PyArrayIterObject *it;
-        Bool anyTRUE = FALSE;
+    intp index;
+    PyArrayIterObject *it;
+    Bool anyTRUE = FALSE;
 
-        it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
-        if (it==NULL) return anyTRUE;
-        index = it->size;
-        while(index--) {
-                if (mp->descr->f->nonzero(it->dataptr, mp)) {
-                        anyTRUE = TRUE;
-                        break;
-                }
-                PyArray_ITER_NEXT(it);
+    it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp);
+    if (it==NULL) return anyTRUE;
+    index = it->size;
+    while(index--) {
+        if (mp->descr->f->nonzero(it->dataptr, mp)) {
+            anyTRUE = TRUE;
+            break;
         }
-        Py_DECREF(it);
-        return anyTRUE;
+        PyArray_ITER_NEXT(it);
+    }
+    Py_DECREF(it);
+    return anyTRUE;
 }
 
 static int
 _array_nonzero(PyArrayObject *mp)
 {
-        intp n;
-        n = PyArray_SIZE(mp);
-        if (n == 1) {
-                return mp->descr->f->nonzero(mp->data, mp);
-        }
-        else if (n == 0) {
-                return 0;
-        }
-        else {
-                PyErr_SetString(PyExc_ValueError,
-                                "The truth value of an array " \
-                                "with more than one element is ambiguous. " \
-                                "Use a.any() or a.all()");
-                return -1;
-        }
+    intp n;
+    n = PyArray_SIZE(mp);
+    if (n == 1) {
+        return mp->descr->f->nonzero(mp->data, mp);
+    }
+    else if (n == 0) {
+        return 0;
+    }
+    else {
+        PyErr_SetString(PyExc_ValueError,
+                        "The truth value of an array " \
+                        "with more than one element is ambiguous. " \
+                        "Use a.any() or a.all()");
+        return -1;
+    }
 }
 
 
@@ -3770,221 +3769,221 @@ _array_nonzero(PyArrayObject *mp)
 static PyObject *
 array_divmod(PyArrayObject *op1, PyObject *op2)
 {
-        PyObject *divp, *modp, *result;
+    PyObject *divp, *modp, *result;
 
-        divp = array_floor_divide(op1, op2);
-        if (divp == NULL) return NULL;
-        modp = array_remainder(op1, op2);
-        if (modp == NULL) {
-                Py_DECREF(divp);
-                return NULL;
-        }
-        result = Py_BuildValue("OO", divp, modp);
+    divp = array_floor_divide(op1, op2);
+    if (divp == NULL) return NULL;
+    modp = array_remainder(op1, op2);
+    if (modp == NULL) {
         Py_DECREF(divp);
-        Py_DECREF(modp);
-        return result;
+        return NULL;
+    }
+    result = Py_BuildValue("OO", divp, modp);
+    Py_DECREF(divp);
+    Py_DECREF(modp);
+    return result;
 }
 
 
 static PyObject *
 array_int(PyArrayObject *v)
 {
-        PyObject *pv, *pv2;
-        if (PyArray_SIZE(v) != 1) {
-                PyErr_SetString(PyExc_TypeError, "only length-1 arrays can be"\
-                                " converted to Python scalars");
-                return NULL;
-        }
-        pv = v->descr->f->getitem(v->data, v);
-        if (pv == NULL) return NULL;
-        if (pv->ob_type->tp_as_number == 0) {
-                PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
-                                "scalar object is not a number");
-                Py_DECREF(pv);
-                return NULL;
-        }
-        if (pv->ob_type->tp_as_number->nb_int == 0) {
-                PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
-                                "scalar number to int");
-                Py_DECREF(pv);
-                return NULL;
-        }
-
-        pv2 = pv->ob_type->tp_as_number->nb_int(pv);
+    PyObject *pv, *pv2;
+    if (PyArray_SIZE(v) != 1) {
+        PyErr_SetString(PyExc_TypeError, "only length-1 arrays can be"\
+                        " converted to Python scalars");
+        return NULL;
+    }
+    pv = v->descr->f->getitem(v->data, v);
+    if (pv == NULL) return NULL;
+    if (pv->ob_type->tp_as_number == 0) {
+        PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
+                        "scalar object is not a number");
+        Py_DECREF(pv);
+        return NULL;
+    }
+    if (pv->ob_type->tp_as_number->nb_int == 0) {
+        PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
+                        "scalar number to int");
         Py_DECREF(pv);
-        return pv2;
+        return NULL;
+    }
+
+    pv2 = pv->ob_type->tp_as_number->nb_int(pv);
+    Py_DECREF(pv);
+    return pv2;
 }
 
 static PyObject *
 array_float(PyArrayObject *v)
 {
-        PyObject *pv, *pv2;
-        if (PyArray_SIZE(v) != 1) {
-                PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
-                                "be converted to Python scalars");
-                return NULL;
-        }
-        pv = v->descr->f->getitem(v->data, v);
-        if (pv == NULL) return NULL;
-        if (pv->ob_type->tp_as_number == 0) {
-                PyErr_SetString(PyExc_TypeError, "cannot convert to a "\
-                                "float; scalar object is not a number");
-                Py_DECREF(pv);
-                return NULL;
-        }
-        if (pv->ob_type->tp_as_number->nb_float == 0) {
-                PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
-                                "scalar number to float");
-                Py_DECREF(pv);
-                return NULL;
-        }
-        pv2 = pv->ob_type->tp_as_number->nb_float(pv);
+    PyObject *pv, *pv2;
+    if (PyArray_SIZE(v) != 1) {
+        PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
+                        "be converted to Python scalars");
+        return NULL;
+    }
+    pv = v->descr->f->getitem(v->data, v);
+    if (pv == NULL) return NULL;
+    if (pv->ob_type->tp_as_number == 0) {
+        PyErr_SetString(PyExc_TypeError, "cannot convert to a "\
+                        "float; scalar object is not a number");
         Py_DECREF(pv);
-        return pv2;
+        return NULL;
+    }
+    if (pv->ob_type->tp_as_number->nb_float == 0) {
+        PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
+                        "scalar number to float");
+        Py_DECREF(pv);
+        return NULL;
+    }
+    pv2 = pv->ob_type->tp_as_number->nb_float(pv);
+    Py_DECREF(pv);
+    return pv2;
 }
 
 static PyObject *
 array_long(PyArrayObject *v)
 {
-        PyObject *pv, *pv2;
-        if (PyArray_SIZE(v) != 1) {
-                PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
-                                "be converted to Python scalars");
-                return NULL;
-        }
-        pv = v->descr->f->getitem(v->data, v);
-        if (pv->ob_type->tp_as_number == 0) {
-                PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
-                                "scalar object is not a number");
-                return NULL;
-        }
-        if (pv->ob_type->tp_as_number->nb_long == 0) {
-                PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
-                                "scalar number to long");
-                return NULL;
-        }
-        pv2 = pv->ob_type->tp_as_number->nb_long(pv);
-        Py_DECREF(pv);
-        return pv2;
+    PyObject *pv, *pv2;
+    if (PyArray_SIZE(v) != 1) {
+        PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
+                        "be converted to Python scalars");
+        return NULL;
+    }
+    pv = v->descr->f->getitem(v->data, v);
+    if (pv->ob_type->tp_as_number == 0) {
+        PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
+                        "scalar object is not a number");
+        return NULL;
+    }
+    if (pv->ob_type->tp_as_number->nb_long == 0) {
+        PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
+                        "scalar number to long");
+        return NULL;
+    }
+    pv2 = pv->ob_type->tp_as_number->nb_long(pv);
+    Py_DECREF(pv);
+    return pv2;
 }
 
 static PyObject *
 array_oct(PyArrayObject *v)
 {
-        PyObject *pv, *pv2;
-        if (PyArray_SIZE(v) != 1) {
-                PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
-                                "be converted to Python scalars");
-                return NULL;
-        }
-        pv = v->descr->f->getitem(v->data, v);
-        if (pv->ob_type->tp_as_number == 0) {
-                PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
-                                "scalar object is not a number");
-                return NULL;
-        }
-        if (pv->ob_type->tp_as_number->nb_oct == 0) {
-                PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
-                                "scalar number to oct");
-                return NULL;
-        }
-        pv2 = pv->ob_type->tp_as_number->nb_oct(pv);
-        Py_DECREF(pv);
-        return pv2;
+    PyObject *pv, *pv2;
+    if (PyArray_SIZE(v) != 1) {
+        PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
+                        "be converted to Python scalars");
+        return NULL;
+    }
+    pv = v->descr->f->getitem(v->data, v);
+    if (pv->ob_type->tp_as_number == 0) {
+        PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
+                        "scalar object is not a number");
+        return NULL;
+    }
+    if (pv->ob_type->tp_as_number->nb_oct == 0) {
+        PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
+                        "scalar number to oct");
+        return NULL;
+    }
+    pv2 = pv->ob_type->tp_as_number->nb_oct(pv);
+    Py_DECREF(pv);
+    return pv2;
 }
 
 static PyObject *
 array_hex(PyArrayObject *v)
 {
-        PyObject *pv, *pv2;
-        if (PyArray_SIZE(v) != 1) {
-                PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
-                                "be converted to Python scalars");
-                return NULL;
-        }
-        pv = v->descr->f->getitem(v->data, v);
-        if (pv->ob_type->tp_as_number == 0) {
-                PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
-                                "scalar object is not a number");
-                return NULL;
-        }
-        if (pv->ob_type->tp_as_number->nb_hex == 0) {
-                PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
-                                "scalar number to hex");
-                return NULL;
-        }
-        pv2 = pv->ob_type->tp_as_number->nb_hex(pv);
-        Py_DECREF(pv);
-        return pv2;
+    PyObject *pv, *pv2;
+    if (PyArray_SIZE(v) != 1) {
+        PyErr_SetString(PyExc_TypeError, "only length-1 arrays can "\
+                        "be converted to Python scalars");
+        return NULL;
+    }
+    pv = v->descr->f->getitem(v->data, v);
+    if (pv->ob_type->tp_as_number == 0) {
+        PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\
+                        "scalar object is not a number");
+        return NULL;
+    }
+    if (pv->ob_type->tp_as_number->nb_hex == 0) {
+        PyErr_SetString(PyExc_TypeError, "don't know how to convert "\
+                        "scalar number to hex");
+        return NULL;
+    }
+    pv2 = pv->ob_type->tp_as_number->nb_hex(pv);
+    Py_DECREF(pv);
+    return pv2;
 }
 
 static PyObject *
 _array_copy_nice(PyArrayObject *self)
 {
-        return PyArray_Return((PyArrayObject *)         \
-                              PyArray_Copy(self));
+    return PyArray_Return((PyArrayObject *)         \
+                          PyArray_Copy(self));
 }
 
 #if PY_VERSION_HEX >= 0x02050000
 static PyObject *
 array_index(PyArrayObject *v)
 {
-        if (!PyArray_ISINTEGER(v) || PyArray_SIZE(v) != 1) {
-                PyErr_SetString(PyExc_TypeError, "only integer arrays with "     \
-                                "one element can be converted to an index");
-                return NULL;
-        }
-        return v->descr->f->getitem(v->data, v);
+    if (!PyArray_ISINTEGER(v) || PyArray_SIZE(v) != 1) {
+        PyErr_SetString(PyExc_TypeError, "only integer arrays with "     \
+                        "one element can be converted to an index");
+        return NULL;
+    }
+    return v->descr->f->getitem(v->data, v);
 }
 #endif
 
 
 static PyNumberMethods array_as_number = {
-        (binaryfunc)array_add,              /*nb_add*/
-        (binaryfunc)array_subtract,                 /*nb_subtract*/
-        (binaryfunc)array_multiply,                 /*nb_multiply*/
-        (binaryfunc)array_divide,                   /*nb_divide*/
-        (binaryfunc)array_remainder,               /*nb_remainder*/
-        (binaryfunc)array_divmod,                   /*nb_divmod*/
-        (ternaryfunc)array_power,                   /*nb_power*/
-        (unaryfunc)array_negative,                  /*nb_neg*/
-        (unaryfunc)_array_copy_nice,                /*nb_pos*/
-        (unaryfunc)array_absolute,                  /*(unaryfunc)array_abs,*/
-        (inquiry)_array_nonzero,                    /*nb_nonzero*/
-        (unaryfunc)array_invert,                    /*nb_invert*/
-        (binaryfunc)array_left_shift,       /*nb_lshift*/
-        (binaryfunc)array_right_shift,      /*nb_rshift*/
-        (binaryfunc)array_bitwise_and,      /*nb_and*/
-        (binaryfunc)array_bitwise_xor,      /*nb_xor*/
-        (binaryfunc)array_bitwise_or,       /*nb_or*/
-        0,                                  /*nb_coerce*/
-        (unaryfunc)array_int,               /*nb_int*/
-        (unaryfunc)array_long,              /*nb_long*/
-        (unaryfunc)array_float,             /*nb_float*/
-        (unaryfunc)array_oct,               /*nb_oct*/
-        (unaryfunc)array_hex,               /*nb_hex*/
-
-        /*This code adds augmented assignment functionality*/
-        /*that was made available in Python 2.0*/
-        (binaryfunc)array_inplace_add,      /*inplace_add*/
-        (binaryfunc)array_inplace_subtract,         /*inplace_subtract*/
-        (binaryfunc)array_inplace_multiply,         /*inplace_multiply*/
-        (binaryfunc)array_inplace_divide,           /*inplace_divide*/
-        (binaryfunc)array_inplace_remainder,    /*inplace_remainder*/
-        (ternaryfunc)array_inplace_power,           /*inplace_power*/
-        (binaryfunc)array_inplace_left_shift,   /*inplace_lshift*/
-        (binaryfunc)array_inplace_right_shift,  /*inplace_rshift*/
-        (binaryfunc)array_inplace_bitwise_and,  /*inplace_and*/
-        (binaryfunc)array_inplace_bitwise_xor,  /*inplace_xor*/
-        (binaryfunc)array_inplace_bitwise_or,   /*inplace_or*/
-
-        (binaryfunc)array_floor_divide,      /*nb_floor_divide*/
-        (binaryfunc)array_true_divide,       /*nb_true_divide*/
-        (binaryfunc)array_inplace_floor_divide,  /*nb_inplace_floor_divide*/
-        (binaryfunc)array_inplace_true_divide,   /*nb_inplace_true_divide*/
+    (binaryfunc)array_add,              /*nb_add*/
+    (binaryfunc)array_subtract,                 /*nb_subtract*/
+    (binaryfunc)array_multiply,                 /*nb_multiply*/
+    (binaryfunc)array_divide,                   /*nb_divide*/
+    (binaryfunc)array_remainder,               /*nb_remainder*/
+    (binaryfunc)array_divmod,                   /*nb_divmod*/
+    (ternaryfunc)array_power,                   /*nb_power*/
+    (unaryfunc)array_negative,                  /*nb_neg*/
+    (unaryfunc)_array_copy_nice,                /*nb_pos*/
+    (unaryfunc)array_absolute,                  /*(unaryfunc)array_abs,*/
+    (inquiry)_array_nonzero,                    /*nb_nonzero*/
+    (unaryfunc)array_invert,                    /*nb_invert*/
+    (binaryfunc)array_left_shift,       /*nb_lshift*/
+    (binaryfunc)array_right_shift,      /*nb_rshift*/
+    (binaryfunc)array_bitwise_and,      /*nb_and*/
+    (binaryfunc)array_bitwise_xor,      /*nb_xor*/
+    (binaryfunc)array_bitwise_or,       /*nb_or*/
+    0,                                  /*nb_coerce*/
+    (unaryfunc)array_int,               /*nb_int*/
+    (unaryfunc)array_long,              /*nb_long*/
+    (unaryfunc)array_float,             /*nb_float*/
+    (unaryfunc)array_oct,               /*nb_oct*/
+    (unaryfunc)array_hex,               /*nb_hex*/
+
+    /*This code adds augmented assignment functionality*/
+    /*that was made available in Python 2.0*/
+    (binaryfunc)array_inplace_add,      /*inplace_add*/
+    (binaryfunc)array_inplace_subtract,         /*inplace_subtract*/
+    (binaryfunc)array_inplace_multiply,         /*inplace_multiply*/
+    (binaryfunc)array_inplace_divide,           /*inplace_divide*/
+    (binaryfunc)array_inplace_remainder,    /*inplace_remainder*/
+    (ternaryfunc)array_inplace_power,           /*inplace_power*/
+    (binaryfunc)array_inplace_left_shift,   /*inplace_lshift*/
+    (binaryfunc)array_inplace_right_shift,  /*inplace_rshift*/
+    (binaryfunc)array_inplace_bitwise_and,  /*inplace_and*/
+    (binaryfunc)array_inplace_bitwise_xor,  /*inplace_xor*/
+    (binaryfunc)array_inplace_bitwise_or,   /*inplace_or*/
+
+    (binaryfunc)array_floor_divide,      /*nb_floor_divide*/
+    (binaryfunc)array_true_divide,       /*nb_true_divide*/
+    (binaryfunc)array_inplace_floor_divide,  /*nb_inplace_floor_divide*/
+    (binaryfunc)array_inplace_true_divide,   /*nb_inplace_true_divide*/
 
 #if PY_VERSION_HEX >= 0x02050000
-        (unaryfunc)array_index,                /* nb_index */
+    (unaryfunc)array_index,                /* nb_index */
 #endif
 
 };
@@ -4005,108 +4004,108 @@ static PyObject *
 array_slice(PyArrayObject *self, Py_ssize_t ilow,
             Py_ssize_t ihigh)
 {
-        PyArrayObject *r;
-        Py_ssize_t l;
-        char *data;
+    PyArrayObject *r;
+    Py_ssize_t l;
+    char *data;
 
-        if (self->nd == 0) {
-                PyErr_SetString(PyExc_ValueError, "cannot slice a 0-d array");
-                return NULL;
-        }
+    if (self->nd == 0) {
+        PyErr_SetString(PyExc_ValueError, "cannot slice a 0-d array");
+        return NULL;
+    }
 
-        l=self->dimensions[0];
-        if (ilow < 0) ilow = 0;
-        else if (ilow > l) ilow = l;
-        if (ihigh < ilow) ihigh = ilow;
-        else if (ihigh > l) ihigh = l;
+    l=self->dimensions[0];
+    if (ilow < 0) ilow = 0;
+    else if (ilow > l) ilow = l;
+    if (ihigh < ilow) ihigh = ilow;
+    else if (ihigh > l) ihigh = l;
+
+    if (ihigh != ilow) {
+        data = index2ptr(self, ilow);
+        if (data == NULL) return NULL;
+    } else {
+        data = self->data;
+    }
 
-        if (ihigh != ilow) {
-                data = index2ptr(self, ilow);
-                if (data == NULL) return NULL;
-        } else {
-                data = self->data;
-        }
-
-        self->dimensions[0] = ihigh-ilow;
-        Py_INCREF(self->descr);
-        r = (PyArrayObject *)                                           \
-                PyArray_NewFromDescr(self->ob_type, self->descr,
-                                     self->nd, self->dimensions,
-                                     self->strides, data,
-                                     self->flags, (PyObject *)self);
-        self->dimensions[0] = l;
-        if (r == NULL) return NULL;
-        r->base = (PyObject *)self;
-        Py_INCREF(self);
-        PyArray_UpdateFlags(r, UPDATE_ALL);
-        return (PyObject *)r;
+    self->dimensions[0] = ihigh-ilow;
+    Py_INCREF(self->descr);
+    r = (PyArrayObject *)                                           \
+        PyArray_NewFromDescr(self->ob_type, self->descr,
+                             self->nd, self->dimensions,
+                             self->strides, data,
+                             self->flags, (PyObject *)self);
+    self->dimensions[0] = l;
+    if (r == NULL) return NULL;
+    r->base = (PyObject *)self;
+    Py_INCREF(self);
+    PyArray_UpdateFlags(r, UPDATE_ALL);
+    return (PyObject *)r;
 }
 
 
 static int
 array_ass_slice(PyArrayObject *self, Py_ssize_t ilow,
                 Py_ssize_t ihigh, PyObject *v) {
-        int ret;
-        PyArrayObject *tmp;
+    int ret;
+    PyArrayObject *tmp;
 
-        if (v == NULL) {
-                PyErr_SetString(PyExc_ValueError,
-                                "cannot delete array elements");
-                return -1;
-        }
-        if (!PyArray_ISWRITEABLE(self)) {
-                PyErr_SetString(PyExc_RuntimeError,
-                                "array is not writeable");
-                return -1;
-        }
-        if ((tmp = (PyArrayObject *)array_slice(self, ilow, ihigh)) \
-            == NULL)
-                return -1;
-        ret = PyArray_CopyObject(tmp, v);
-        Py_DECREF(tmp);
+    if (v == NULL) {
+        PyErr_SetString(PyExc_ValueError,
+                        "cannot delete array elements");
+        return -1;
+    }
+    if (!PyArray_ISWRITEABLE(self)) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "array is not writeable");
+        return -1;
+    }
+    if ((tmp = (PyArrayObject *)array_slice(self, ilow, ihigh)) \
+        == NULL)
+        return -1;
+    ret = PyArray_CopyObject(tmp, v);
+    Py_DECREF(tmp);
 
-        return ret;
+    return ret;
 }
 
 static int
 array_contains(PyArrayObject *self, PyObject *el)
 {
-        /* equivalent to (self == el).any() */
+    /* equivalent to (self == el).any() */
 
-        PyObject *res;
-        int ret;
+    PyObject *res;
+    int ret;
 
-        res = PyArray_EnsureAnyArray(PyObject_RichCompare((PyObject *)self,
-                                                          el, Py_EQ));
-        if (res == NULL) return -1;
-        ret = array_any_nonzero((PyArrayObject *)res);
-        Py_DECREF(res);
-        return ret;
+    res = PyArray_EnsureAnyArray(PyObject_RichCompare((PyObject *)self,
+                                                      el, Py_EQ));
+    if (res == NULL) return -1;
+    ret = array_any_nonzero((PyArrayObject *)res);
+    Py_DECREF(res);
+    return ret;
 }
 
 static PySequenceMethods array_as_sequence = {
 #if PY_VERSION_HEX >= 0x02050000
-        (lenfunc)array_length,          /*sq_length*/
-        (binaryfunc)NULL,               /* sq_concat is handled by nb_add*/
-        (ssizeargfunc)NULL,             
-        (ssizeargfunc)array_item_nice,
-        (ssizessizeargfunc)array_slice,
-        (ssizeobjargproc)array_ass_item,               /*sq_ass_item*/
-        (ssizessizeobjargproc)array_ass_slice,  /*sq_ass_slice*/
-        (objobjproc) array_contains,           /* sq_contains */
-        (binaryfunc) NULL,                  /* sg_inplace_concat */
-        (ssizeargfunc)NULL,
+    (lenfunc)array_length,          /*sq_length*/
+    (binaryfunc)NULL,               /* sq_concat is handled by nb_add*/
+    (ssizeargfunc)NULL,
+    (ssizeargfunc)array_item_nice,
+    (ssizessizeargfunc)array_slice,
+    (ssizeobjargproc)array_ass_item,               /*sq_ass_item*/
+    (ssizessizeobjargproc)array_ass_slice,  /*sq_ass_slice*/
+    (objobjproc) array_contains,           /* sq_contains */
+    (binaryfunc) NULL,                  /* sg_inplace_concat */
+    (ssizeargfunc)NULL,
 #else
-        (inquiry)array_length,          /*sq_length*/
-        (binaryfunc)NULL, /* sq_concat is handled by nb_add*/
-        (intargfunc)NULL, /* sq_repeat is handled nb_multiply*/
-        (intargfunc)array_item_nice,            /*sq_item*/
-        (intintargfunc)array_slice,             /*sq_slice*/
-        (intobjargproc)array_ass_item,         /*sq_ass_item*/
-        (intintobjargproc)array_ass_slice,      /*sq_ass_slice*/
-        (objobjproc) array_contains,           /* sq_contains */
-        (binaryfunc) NULL,                  /* sg_inplace_concat */
-        (intargfunc) NULL         /* sg_inplace_repeat */
+    (inquiry)array_length,          /*sq_length*/
+    (binaryfunc)NULL, /* sq_concat is handled by nb_add*/
+    (intargfunc)NULL, /* sq_repeat is handled nb_multiply*/
+    (intargfunc)array_item_nice,            /*sq_item*/
+    (intintargfunc)array_slice,             /*sq_slice*/
+    (intobjargproc)array_ass_item,         /*sq_ass_item*/
+    (intintobjargproc)array_ass_slice,      /*sq_ass_slice*/
+    (objobjproc) array_contains,           /* sq_contains */
+    (binaryfunc) NULL,                  /* sg_inplace_concat */
+    (intargfunc) NULL         /* sg_inplace_repeat */
 #endif
 };
 
@@ -4118,48 +4117,48 @@ static int
 dump_data(char **string, int *n, int *max_n, char *data, int nd,
           intp *dimensions, intp *strides, PyArrayObject* self)
 {
-        PyArray_Descr *descr=self->descr;
-        PyObject *op, *sp;
-        char *ostring;
-        int i, N;
-
-#define CHECK_MEMORY if (*n >= *max_n-16) { *max_n *= 2; \
-                *string = (char *)_pya_realloc(*string, *max_n); }
-
-        if (nd == 0) {
-
-                if ((op = descr->f->getitem(data, self)) == NULL) return -1;
-                sp = PyObject_Repr(op);
-                if (sp == NULL) {Py_DECREF(op); return -1;}
-                ostring = PyString_AsString(sp);
-                N = PyString_Size(sp)*sizeof(char);
-                *n += N;
-                CHECK_MEMORY
-                        memmove(*string+(*n-N), ostring, N);
-                Py_DECREF(sp);
-                Py_DECREF(op);
-                return 0;
-        } else {
-                CHECK_MEMORY
-                        (*string)[*n] = '[';
-                *n += 1;
-                for(i=0; i<dimensions[0]; i++) {
-                        if (dump_data(string, n, max_n,
-                                      data+(*strides)*i,
-                                      nd-1, dimensions+1,
-                                      strides+1, self) < 0)
-                                return -1;
-                                CHECK_MEMORY
-                                        if (i<dimensions[0]-1) {
-                                                (*string)[*n] = ',';
-                                                (*string)[*n+1] = ' ';
-                                                *n += 2;
-                                        }
+    PyArray_Descr *descr=self->descr;
+    PyObject *op, *sp;
+    char *ostring;
+    int i, N;
+
+#define CHECK_MEMORY if (*n >= *max_n-16) { *max_n *= 2;        \
+        *string = (char *)_pya_realloc(*string, *max_n); }
+
+    if (nd == 0) {
+
+        if ((op = descr->f->getitem(data, self)) == NULL) return -1;
+        sp = PyObject_Repr(op);
+        if (sp == NULL) {Py_DECREF(op); return -1;}
+        ostring = PyString_AsString(sp);
+        N = PyString_Size(sp)*sizeof(char);
+        *n += N;
+        CHECK_MEMORY
+            memmove(*string+(*n-N), ostring, N);
+        Py_DECREF(sp);
+        Py_DECREF(op);
+        return 0;
+    } else {
+        CHECK_MEMORY
+            (*string)[*n] = '[';
+        *n += 1;
+        for(i=0; i<dimensions[0]; i++) {
+            if (dump_data(string, n, max_n,
+                          data+(*strides)*i,
+                          nd-1, dimensions+1,
+                          strides+1, self) < 0)
+                return -1;
+            CHECK_MEMORY
+                if (i<dimensions[0]-1) {
+                    (*string)[*n] = ',';
+                    (*string)[*n+1] = ' ';
+                    *n += 2;
                 }
-                CHECK_MEMORY
-                        (*string)[*n] = ']'; *n += 1;
-                return 0;
         }
+        CHECK_MEMORY
+            (*string)[*n] = ']'; *n += 1;
+        return 0;
+    }
 
 #undef CHECK_MEMORY
 }
@@ -4167,104 +4166,104 @@ dump_data(char **string, int *n, int *max_n, char *data, int nd,
 static PyObject *
 array_repr_builtin(PyArrayObject *self, int repr)
 {
-        PyObject *ret;
-        char *string;
-        int n, max_n;
+    PyObject *ret;
+    char *string;
+    int n, max_n;
 
-        max_n = PyArray_NBYTES(self)*4*sizeof(char) + 7;
+    max_n = PyArray_NBYTES(self)*4*sizeof(char) + 7;
 
-        if ((string = (char *)_pya_malloc(max_n)) == NULL) {
-                PyErr_SetString(PyExc_MemoryError, "out of memory");
-                return NULL;
-        }
+    if ((string = (char *)_pya_malloc(max_n)) == NULL) {
+        PyErr_SetString(PyExc_MemoryError, "out of memory");
+        return NULL;
+    }
 
-        if (repr) {
-                n = 6;
-                sprintf(string, "array(");
-        }
-        else {
-                n = 0;
-        }
-        if (dump_data(&string, &n, &max_n, self->data,
-                      self->nd, self->dimensions,
-                      self->strides, self) < 0) {
-                _pya_free(string); return NULL;
-        }
+    if (repr) {
+        n = 6;
+        sprintf(string, "array(");
+    }
+    else {
+        n = 0;
+    }
+    if (dump_data(&string, &n, &max_n, self->data,
+                  self->nd, self->dimensions,
+                  self->strides, self) < 0) {
+        _pya_free(string); return NULL;
+    }
 
-        if (repr) {
-                if (PyArray_ISEXTENDED(self)) {
-                        char buf[100];
-                        snprintf(buf, sizeof(buf), "%d", self->descr->elsize);
-                        sprintf(string+n, ", '%c%s')", self->descr->type, buf);
-                        ret = PyString_FromStringAndSize(string, n+6+strlen(buf));
-                }
-                else {
-                        sprintf(string+n, ", '%c')", self->descr->type);
-                        ret = PyString_FromStringAndSize(string, n+6);
-                }
+    if (repr) {
+        if (PyArray_ISEXTENDED(self)) {
+            char buf[100];
+            snprintf(buf, sizeof(buf), "%d", self->descr->elsize);
+            sprintf(string+n, ", '%c%s')", self->descr->type, buf);
+            ret = PyString_FromStringAndSize(string, n+6+strlen(buf));
         }
         else {
-                ret = PyString_FromStringAndSize(string, n);
+            sprintf(string+n, ", '%c')", self->descr->type);
+            ret = PyString_FromStringAndSize(string, n+6);
         }
+    }
+    else {
+        ret = PyString_FromStringAndSize(string, n);
+    }
 
-        _pya_free(string);
-        return ret;
+    _pya_free(string);
+    return ret;
 }
 
 static PyObject *PyArray_StrFunction=NULL;
 static PyObject *PyArray_ReprFunction=NULL;
 
 /*OBJECT_API
- Set the array print function to be a Python function.
+  Set the array print function to be a Python function.
 */
 static void
 PyArray_SetStringFunction(PyObject *op, int repr)
 {
-        if (repr) {
-                /* Dispose of previous callback */
-                Py_XDECREF(PyArray_ReprFunction);
-                /* Add a reference to new callback */
-                Py_XINCREF(op);
-                /* Remember new callback */
-                PyArray_ReprFunction = op;
-        } else {
-                /* Dispose of previous callback */
-                Py_XDECREF(PyArray_StrFunction);
-                /* Add a reference to new callback */
-                Py_XINCREF(op);
-                /* Remember new callback */
-                PyArray_StrFunction = op;
-        }
+    if (repr) {
+        /* Dispose of previous callback */
+        Py_XDECREF(PyArray_ReprFunction);
+        /* Add a reference to new callback */
+        Py_XINCREF(op);
+        /* Remember new callback */
+        PyArray_ReprFunction = op;
+    } else {
+        /* Dispose of previous callback */
+        Py_XDECREF(PyArray_StrFunction);
+        /* Add a reference to new callback */
+        Py_XINCREF(op);
+        /* Remember new callback */
+        PyArray_StrFunction = op;
+    }
 }
 
 static PyObject *
 array_repr(PyArrayObject *self)
 {
-        PyObject *s, *arglist;
+    PyObject *s, *arglist;
 
-        if (PyArray_ReprFunction == NULL) {
-                s = array_repr_builtin(self, 1);
-        } else {
-                arglist = Py_BuildValue("(O)", self);
-                s = PyEval_CallObject(PyArray_ReprFunction, arglist);
-                Py_DECREF(arglist);
-        }
-        return s;
+    if (PyArray_ReprFunction == NULL) {
+        s = array_repr_builtin(self, 1);
+    } else {
+        arglist = Py_BuildValue("(O)", self);
+        s = PyEval_CallObject(PyArray_ReprFunction, arglist);
+        Py_DECREF(arglist);
+    }
+    return s;
 }
 
 static PyObject *
 array_str(PyArrayObject *self)
 {
-        PyObject *s, *arglist;
+    PyObject *s, *arglist;
 
-        if (PyArray_StrFunction == NULL) {
-                s = array_repr_builtin(self, 0);
-        } else {
-                arglist = Py_BuildValue("(O)", self);
-                s = PyEval_CallObject(PyArray_StrFunction, arglist);
-                Py_DECREF(arglist);
-        }
-        return s;
+    if (PyArray_StrFunction == NULL) {
+        s = array_repr_builtin(self, 0);
+    } else {
+        arglist = Py_BuildValue("(O)", self);
+        s = PyEval_CallObject(PyArray_StrFunction, arglist);
+        Py_DECREF(arglist);
+    }
+    return s;
 }
 
 
@@ -4274,15 +4273,15 @@ array_str(PyArrayObject *self)
 static int
 PyArray_CompareUCS4(npy_ucs4 *s1, npy_ucs4 *s2, register size_t len)
 {
-        register PyArray_UCS4 c1, c2;
-        while(len-- > 0) {
-                c1 = *s1++;
-                c2 = *s2++;
-                if (c1 != c2) {
-                        return (c1 < c2) ? -1 : 1;
-                }
+    register PyArray_UCS4 c1, c2;
+    while(len-- > 0) {
+        c1 = *s1++;
+        c2 = *s2++;
+        if (c1 != c2) {
+            return (c1 < c2) ? -1 : 1;
         }
-        return 0;
+    }
+    return 0;
 }
 
 /* This also handles possibly mis-aligned data */
@@ -4294,36 +4293,36 @@ PyArray_CompareUCS4(npy_ucs4 *s1, npy_ucs4 *s2, register size_t len)
 static int
 _myunincmp(PyArray_UCS4 *s1, PyArray_UCS4 *s2, int len1, int len2)
 {
-        PyArray_UCS4 *sptr;
-        PyArray_UCS4 *s1t=s1, *s2t=s2;
-        int val;
-        intp size;
-        int diff;
+    PyArray_UCS4 *sptr;
+    PyArray_UCS4 *s1t=s1, *s2t=s2;
+    int val;
+    intp size;
+    int diff;
 
-        if ((intp)s1 % sizeof(PyArray_UCS4) != 0) {
-                size = len1*sizeof(PyArray_UCS4);
-                s1t = malloc(size);
-                memcpy(s1t, s1, size);
-        }
-        if ((intp)s2 % sizeof(PyArray_UCS4) != 0) {
-                size = len2*sizeof(PyArray_UCS4);
-                s2t = malloc(size);
-                memcpy(s2t, s2, size);
-        }
-        val = PyArray_CompareUCS4(s1t, s2t, MIN(len1,len2));
-        if ((val != 0) || (len1 == len2)) goto finish;
-        if (len2 > len1) {sptr = s2t+len1; val = -1; diff=len2-len1;}
-        else {sptr = s1t+len2; val = 1; diff=len1-len2;}
-        while (diff--) {
-                if (*sptr != 0) goto finish;
-                sptr++;
-        }
-        val = 0;
+    if ((intp)s1 % sizeof(PyArray_UCS4) != 0) {
+        size = len1*sizeof(PyArray_UCS4);
+        s1t = malloc(size);
+        memcpy(s1t, s1, size);
+    }
+    if ((intp)s2 % sizeof(PyArray_UCS4) != 0) {
+        size = len2*sizeof(PyArray_UCS4);
+        s2t = malloc(size);
+        memcpy(s2t, s2, size);
+    }
+    val = PyArray_CompareUCS4(s1t, s2t, MIN(len1,len2));
+    if ((val != 0) || (len1 == len2)) goto finish;
+    if (len2 > len1) {sptr = s2t+len1; val = -1; diff=len2-len1;}
+    else {sptr = s1t+len2; val = 1; diff=len1-len2;}
+    while (diff--) {
+        if (*sptr != 0) goto finish;
+        sptr++;
+    }
+    val = 0;
 
  finish:
-        if (s1t != s1) free(s1t);
-        if (s2t != s2) free(s2t);
-        return val;
+    if (s1t != s1) free(s1t);
+    if (s2t != s2) free(s2t);
+    return val;
 }
 
 
@@ -4337,19 +4336,19 @@ _myunincmp(PyArray_UCS4 *s1, PyArray_UCS4 *s2, int len1, int len2)
 static int
 _mystrncmp(char *s1, char *s2, int len1, int len2)
 {
-        char *sptr;
-        int val;
-        int diff;
-
-        val = memcmp(s1, s2, MIN(len1, len2));
-        if ((val != 0) || (len1 == len2)) return val;
-        if (len2 > len1) {sptr = s2+len1; val = -1; diff=len2-len1;}
-        else {sptr = s1+len2; val = 1; diff=len1-len2;}
-        while (diff--) {
-                if (*sptr != 0) return val; 
-                sptr++;
-        }
-        return 0; /* Only happens if NULLs are everywhere */
+    char *sptr;
+    int val;
+    int diff;
+
+    val = memcmp(s1, s2, MIN(len1, len2));
+    if ((val != 0) || (len1 == len2)) return val;
+    if (len2 > len1) {sptr = s2+len1; val = -1; diff=len2-len1;}
+    else {sptr = s1+len2; val = 1; diff=len1-len2;}
+    while (diff--) {
+        if (*sptr != 0) return val;
+        sptr++;
+    }
+    return 0; /* Only happens if NULLs are everywhere */
 }
 
 /* Borrowed from Numarray */
@@ -4363,27 +4362,27 @@ _mystrncmp(char *s1, char *s2, int len1, int len2)
 
 static void _rstripw(char *s, int n)
 {
-        int i;
-        for(i=n-1; i>=1; i--)  /* Never strip to length 0. */
+    int i;
+    for(i=n-1; i>=1; i--)  /* Never strip to length 0. */
         {
-                int c = s[i];
-                if (!c || isspace(c))
-                        s[i] = 0;
-                else
-                        break;
+            int c = s[i];
+            if (!c || isspace(c))
+                s[i] = 0;
+            else
+                break;
         }
 }
 
 static void _unistripw(PyArray_UCS4 *s, int n)
 {
-        int i;
-        for(i=n-1; i>=1; i--)  /* Never strip to length 0. */
+    int i;
+    for(i=n-1; i>=1; i--)  /* Never strip to length 0. */
         {
-                PyArray_UCS4 c = s[i];
-                if (!c || isspace(c))
-                        s[i] = 0;
-                else
-                        break;
+            PyArray_UCS4 c = s[i];
+            if (!c || isspace(c))
+                s[i] = 0;
+            else
+                break;
         }
 }
 
@@ -4391,143 +4390,143 @@ static void _unistripw(PyArray_UCS4 *s, int n)
 static char *
 _char_copy_n_strip(char *original, char *temp, int nc)
 {
-        if (nc > SMALL_STRING) {
-                temp = malloc(nc);
-                if (!temp) {
-                        PyErr_NoMemory();
-                        return NULL;
-                }
+    if (nc > SMALL_STRING) {
+        temp = malloc(nc);
+        if (!temp) {
+            PyErr_NoMemory();
+            return NULL;
         }
-        memcpy(temp, original, nc);
-        _rstripw(temp, nc);
-        return temp;
+    }
+    memcpy(temp, original, nc);
+    _rstripw(temp, nc);
+    return temp;
 }
 
 static void
 _char_release(char *ptr, int nc)
 {
-        if (nc > SMALL_STRING) {
-                free(ptr);
-        }
+    if (nc > SMALL_STRING) {
+        free(ptr);
+    }
 }
 
 static char *
 _uni_copy_n_strip(char *original, char *temp, int nc)
 {
-        if (nc*sizeof(PyArray_UCS4) > SMALL_STRING) {
-                temp = malloc(nc*sizeof(PyArray_UCS4));
-                if (!temp) {
-                        PyErr_NoMemory();
-                        return NULL;
-                }
+    if (nc*sizeof(PyArray_UCS4) > SMALL_STRING) {
+        temp = malloc(nc*sizeof(PyArray_UCS4));
+        if (!temp) {
+            PyErr_NoMemory();
+            return NULL;
         }
-        memcpy(temp, original, nc*sizeof(PyArray_UCS4));
-        _unistripw((PyArray_UCS4 *)temp, nc);
-        return temp;
+    }
+    memcpy(temp, original, nc*sizeof(PyArray_UCS4));
+    _unistripw((PyArray_UCS4 *)temp, nc);
+    return temp;
 }
 
 static void
 _uni_release(char *ptr, int nc)
 {
-        if (nc*sizeof(PyArray_UCS4) > SMALL_STRING) {
-                free(ptr);
-        }
+    if (nc*sizeof(PyArray_UCS4) > SMALL_STRING) {
+        free(ptr);
+    }
 }
 
 
 /* End borrowed from numarray */
 
-#define _rstrip_loop(CMP) {                     \
-                void *aptr, *bptr; \
-                char atemp[SMALL_STRING], btemp[SMALL_STRING]; \
-                while(size--) { \
-                        aptr = stripfunc(iself->dataptr, atemp, N1); \
-                        if (!aptr) return -1; \
-                        bptr = stripfunc(iother->dataptr, btemp, N2); \
-                        if (!bptr) { \
-                                relfunc(aptr, N1); \
-                                return -1; \
-                        } \
-                        val = cmpfunc(aptr, bptr, N1, N2); \
-                        *dptr = (val CMP 0); \
-                        PyArray_ITER_NEXT(iself); \
-                        PyArray_ITER_NEXT(iother); \
-                        dptr += 1; \
-                        relfunc(aptr, N1); \
-                        relfunc(bptr, N2); \
-                } \
-        }
-
-#define _reg_loop(CMP) { \
-                while(size--) {                                 \
-                        val = cmpfunc((void *)iself->dataptr,   \
-                                      (void *)iother->dataptr,  \
-                                      N1, N2);                  \
-                        *dptr = (val CMP 0);                    \
-                        PyArray_ITER_NEXT(iself);               \
-                        PyArray_ITER_NEXT(iother);              \
-                        dptr += 1;                              \
-                } \
-        }
-
-#define _loop(CMP) if (rstrip) _rstrip_loop(CMP) \
+#define _rstrip_loop(CMP) {                                     \
+        void *aptr, *bptr;                                      \
+        char atemp[SMALL_STRING], btemp[SMALL_STRING];          \
+        while(size--) {                                         \
+            aptr = stripfunc(iself->dataptr, atemp, N1);        \
+            if (!aptr) return -1;                               \
+            bptr = stripfunc(iother->dataptr, btemp, N2);       \
+            if (!bptr) {                                        \
+                relfunc(aptr, N1);                              \
+                return -1;                                      \
+            }                                                   \
+            val = cmpfunc(aptr, bptr, N1, N2);                  \
+            *dptr = (val CMP 0);                                \
+            PyArray_ITER_NEXT(iself);                           \
+            PyArray_ITER_NEXT(iother);                          \
+            dptr += 1;                                          \
+            relfunc(aptr, N1);                                  \
+            relfunc(bptr, N2);                                  \
+        }                                                       \
+    }
+
+#define _reg_loop(CMP) {                                \
+        while(size--) {                                 \
+            val = cmpfunc((void *)iself->dataptr,       \
+                          (void *)iother->dataptr,      \
+                          N1, N2);                      \
+            *dptr = (val CMP 0);                        \
+            PyArray_ITER_NEXT(iself);                   \
+            PyArray_ITER_NEXT(iother);                  \
+            dptr += 1;                                  \
+        }                                               \
+    }
+
+#define _loop(CMP) if (rstrip) _rstrip_loop(CMP)        \
         else _reg_loop(CMP)
 
 static int
 _compare_strings(PyObject *result, PyArrayMultiIterObject *multi,
                  int cmp_op, void *func, int rstrip)
 {
-        PyArrayIterObject *iself, *iother;
-        Bool *dptr;
-        intp size;
-        int val;
-        int N1, N2;
-        int (*cmpfunc)(void *, void *, int, int);
-        void (*relfunc)(char *, int);
-        char* (*stripfunc)(char *, char *, int);
-
-        cmpfunc = func;
-        dptr = (Bool *)PyArray_DATA(result);
-        iself = multi->iters[0];
-        iother = multi->iters[1];
-        size = multi->size;
-        N1 = iself->ao->descr->elsize;
-        N2 = iother->ao->descr->elsize;
-        if ((void *)cmpfunc == (void *)_myunincmp) {
-                N1 >>= 2;
-                N2 >>= 2;
-                stripfunc = _uni_copy_n_strip;
-                relfunc = _uni_release;
-        }
-        else {
-                stripfunc = _char_copy_n_strip;
-                relfunc = _char_release;
-        }
-        switch (cmp_op) {
-        case Py_EQ:
-                _loop(==)
-                break;
-        case Py_NE:
-                _loop(!=)
-                break;
-        case Py_LT:
-                _loop(<)
-                break;
-        case Py_LE:
-                _loop(<=)
-                break;
-        case Py_GT:
-                _loop(>)
-                break;
-        case Py_GE:
-                _loop(>=)
-                break;
-        default:
-                PyErr_SetString(PyExc_RuntimeError,
-                                "bad comparison operator");
-                return -1;
-        }
-        return 0;
+    PyArrayIterObject *iself, *iother;
+    Bool *dptr;
+    intp size;
+    int val;
+    int N1, N2;
+    int (*cmpfunc)(void *, void *, int, int);
+    void (*relfunc)(char *, int);
+    char* (*stripfunc)(char *, char *, int);
+
+    cmpfunc = func;
+    dptr = (Bool *)PyArray_DATA(result);
+    iself = multi->iters[0];
+    iother = multi->iters[1];
+    size = multi->size;
+    N1 = iself->ao->descr->elsize;
+    N2 = iother->ao->descr->elsize;
+    if ((void *)cmpfunc == (void *)_myunincmp) {
+        N1 >>= 2;
+        N2 >>= 2;
+        stripfunc = _uni_copy_n_strip;
+        relfunc = _uni_release;
+    }
+    else {
+        stripfunc = _char_copy_n_strip;
+        relfunc = _char_release;
+    }
+    switch (cmp_op) {
+    case Py_EQ:
+        _loop(==)
+            break;
+    case Py_NE:
+        _loop(!=)
+            break;
+    case Py_LT:
+        _loop(<)
+            break;
+    case Py_LE:
+        _loop(<=)
+            break;
+    case Py_GT:
+        _loop(>)
+            break;
+    case Py_GE:
+        _loop(>=)
+            break;
+    default:
+        PyErr_SetString(PyExc_RuntimeError,
+                        "bad comparison operator");
+        return -1;
+    }
+    return 0;
 }
 
 #undef _loop
@@ -4539,82 +4538,82 @@ static PyObject *
 _strings_richcompare(PyArrayObject *self, PyArrayObject *other, int cmp_op,
                      int rstrip)
 {
-        PyObject *result;
-        PyArrayMultiIterObject *mit;
-        int val;
-
-        /* Cast arrays to a common type */
-        if (self->descr->type_num != other->descr->type_num) {
-                PyObject *new;
-                if (self->descr->type_num == PyArray_STRING && \
-                    other->descr->type_num == PyArray_UNICODE) {
-                        Py_INCREF(other);
-                        Py_INCREF(other->descr);
-                        new = PyArray_FromAny((PyObject *)self, other->descr,
-                                              0, 0, 0, NULL);
-                        if (new == NULL) return NULL;
-                        self = (PyArrayObject *)new;
-                }
-                else if (self->descr->type_num == PyArray_UNICODE &&    \
-                         other->descr->type_num == PyArray_STRING) {
-                        Py_INCREF(self);
-                        Py_INCREF(self->descr);
-                        new = PyArray_FromAny((PyObject *)other, self->descr,
-                                              0, 0, 0, NULL);
-                        if (new == NULL) return NULL;
-                        other = (PyArrayObject *)new;
-                }
-                else {
-                        PyErr_SetString(PyExc_TypeError,
-                                        "invalid string data-types "
-                                        "in comparison");
-                        return NULL;
-                }
-        }
-        else {
-                Py_INCREF(self);
-                Py_INCREF(other);
-        }
+    PyObject *result;
+    PyArrayMultiIterObject *mit;
+    int val;
 
-        /* Broad-cast the arrays to a common shape */
-        mit = (PyArrayMultiIterObject *)PyArray_MultiIterNew(2, self, other);
-        Py_DECREF(self);
-        Py_DECREF(other);
-        if (mit == NULL) return NULL;
-
-        result = PyArray_NewFromDescr(&PyArray_Type,
-                                      PyArray_DescrFromType(PyArray_BOOL),
-                                      mit->nd,
-                                      mit->dimensions,
-                                      NULL, NULL, 0,
-                                      NULL);
-        if (result == NULL) goto finish;
-
-        if (self->descr->type_num == PyArray_UNICODE) {
-                val = _compare_strings(result, mit, cmp_op, _myunincmp,
-                                       rstrip);
+    /* Cast arrays to a common type */
+    if (self->descr->type_num != other->descr->type_num) {
+        PyObject *new;
+        if (self->descr->type_num == PyArray_STRING && \
+            other->descr->type_num == PyArray_UNICODE) {
+            Py_INCREF(other);
+            Py_INCREF(other->descr);
+            new = PyArray_FromAny((PyObject *)self, other->descr,
+                                  0, 0, 0, NULL);
+            if (new == NULL) return NULL;
+            self = (PyArrayObject *)new;
+        }
+        else if (self->descr->type_num == PyArray_UNICODE &&    \
+                 other->descr->type_num == PyArray_STRING) {
+            Py_INCREF(self);
+            Py_INCREF(self->descr);
+            new = PyArray_FromAny((PyObject *)other, self->descr,
+                                  0, 0, 0, NULL);
+            if (new == NULL) return NULL;
+            other = (PyArrayObject *)new;
         }
         else {
-                val = _compare_strings(result, mit, cmp_op, _mystrncmp,
-                                       rstrip);
+            PyErr_SetString(PyExc_TypeError,
+                            "invalid string data-types "
+                            "in comparison");
+            return NULL;
         }
+    }
+    else {
+        Py_INCREF(self);
+        Py_INCREF(other);
+    }
+
+    /* Broad-cast the arrays to a common shape */
+    mit = (PyArrayMultiIterObject *)PyArray_MultiIterNew(2, self, other);
+    Py_DECREF(self);
+    Py_DECREF(other);
+    if (mit == NULL) return NULL;
+
+    result = PyArray_NewFromDescr(&PyArray_Type,
+                                  PyArray_DescrFromType(PyArray_BOOL),
+                                  mit->nd,
+                                  mit->dimensions,
+                                  NULL, NULL, 0,
+                                  NULL);
+    if (result == NULL) goto finish;
+
+    if (self->descr->type_num == PyArray_UNICODE) {
+        val = _compare_strings(result, mit, cmp_op, _myunincmp,
+                               rstrip);
+    }
+    else {
+        val = _compare_strings(result, mit, cmp_op, _mystrncmp,
+                               rstrip);
+    }
 
-        if (val < 0) {Py_DECREF(result); result = NULL;}
+    if (val < 0) {Py_DECREF(result); result = NULL;}
 
  finish:
-        Py_DECREF(mit);
-        return result;
+    Py_DECREF(mit);
+    return result;
 }
 
 /* VOID-type arrays can only be compared equal and not-equal
-    in which case the fields are all compared by extracting the fields
-    and testing one at a time...
-    equality testing is performed using logical_ands on all the fields.
-    in-equality testing is performed using logical_ors on all the fields.
+   in which case the fields are all compared by extracting the fields
+   and testing one at a time...
+   equality testing is performed using logical_ands on all the fields.
+   in-equality testing is performed using logical_ors on all the fields.
 
-    VOID-type arrays without fields are compared for equality by comparing their
-    memory at each location directly (using string-code).
- */
+   VOID-type arrays without fields are compared for equality by comparing their
+   memory at each location directly (using string-code).
+*/
 
 static PyObject *array_richcompare(PyArrayObject *, PyObject *, int);
 
@@ -4622,334 +4621,334 @@ static PyObject *array_richcompare(PyArrayObject *, PyObject *, int);
 static PyObject *
 _void_compare(PyArrayObject *self, PyArrayObject *other, int cmp_op)
 {
-        if (!(cmp_op == Py_EQ || cmp_op == Py_NE)) {
-                PyErr_SetString(PyExc_ValueError, "Void-arrays can only" \
-                                "be compared for equality.");
-                return NULL;
-        }
-        if (PyArray_HASFIELDS(self)) {
-                PyObject *res=NULL, *temp, *a, *b;
-                PyObject *key, *value, *temp2;
-                PyObject *op;
-                Py_ssize_t pos=0;
-                op = (cmp_op == Py_EQ ? n_ops.logical_and : n_ops.logical_or);
-                while (PyDict_Next(self->descr->fields, &pos, &key, &value)) {
-                        a = PyArray_EnsureAnyArray(array_subscript(self, key));
-                        if (a==NULL) {Py_XDECREF(res); return NULL;}
-                        b = array_subscript(other, key);
-                        if (b==NULL) {Py_XDECREF(res); Py_DECREF(a); return NULL;}
-                        temp = array_richcompare((PyArrayObject *)a,b,cmp_op);
-                        Py_DECREF(a);
-                        Py_DECREF(b);
-                        if (temp == NULL) {Py_XDECREF(res); return NULL;}
-                        if (res == NULL) {
-                                res = temp;
-                        }
-                        else {
-                                temp2 = PyObject_CallFunction(op, "OO", res, temp);
-                                Py_DECREF(temp);
-                                Py_DECREF(res);
-                                if (temp2 == NULL) return NULL;
-                                res = temp2;
-                        }
-                }
-                if (res == NULL && !PyErr_Occurred()) {
-                        PyErr_SetString(PyExc_ValueError, "No fields found.");
-                }
-                return res;
+    if (!(cmp_op == Py_EQ || cmp_op == Py_NE)) {
+        PyErr_SetString(PyExc_ValueError, "Void-arrays can only" \
+                        "be compared for equality.");
+        return NULL;
+    }
+    if (PyArray_HASFIELDS(self)) {
+        PyObject *res=NULL, *temp, *a, *b;
+        PyObject *key, *value, *temp2;
+        PyObject *op;
+        Py_ssize_t pos=0;
+        op = (cmp_op == Py_EQ ? n_ops.logical_and : n_ops.logical_or);
+        while (PyDict_Next(self->descr->fields, &pos, &key, &value)) {
+            a = PyArray_EnsureAnyArray(array_subscript(self, key));
+            if (a==NULL) {Py_XDECREF(res); return NULL;}
+            b = array_subscript(other, key);
+            if (b==NULL) {Py_XDECREF(res); Py_DECREF(a); return NULL;}
+            temp = array_richcompare((PyArrayObject *)a,b,cmp_op);
+            Py_DECREF(a);
+            Py_DECREF(b);
+            if (temp == NULL) {Py_XDECREF(res); return NULL;}
+            if (res == NULL) {
+                res = temp;
+            }
+            else {
+                temp2 = PyObject_CallFunction(op, "OO", res, temp);
+                Py_DECREF(temp);
+                Py_DECREF(res);
+                if (temp2 == NULL) return NULL;
+                res = temp2;
+            }
         }
-        else { /* compare as a string */
-                /* assumes self and other have same descr->type */
-                return _strings_richcompare(self, other, cmp_op, 0);
+        if (res == NULL && !PyErr_Occurred()) {
+            PyErr_SetString(PyExc_ValueError, "No fields found.");
         }
+        return res;
+    }
+    else { /* compare as a string */
+        /* assumes self and other have same descr->type */
+        return _strings_richcompare(self, other, cmp_op, 0);
+    }
 }
 
 static PyObject *
 array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op)
 {
-        PyObject *array_other, *result = NULL;
-        int typenum;
-
-        switch (cmp_op)
-                {
-                case Py_LT:
-                        result = PyArray_GenericBinaryFunction(self, other,
-                                                               n_ops.less);
-                        break;
-                case Py_LE:
-                        result = PyArray_GenericBinaryFunction(self, other,
-                                                               n_ops.less_equal);
-                        break;
-                case Py_EQ:
-                        if (other == Py_None) {
-                                Py_INCREF(Py_False);
-                                return Py_False;
-                        }
-                        /* Try to convert other to an array */
-                        if (!PyArray_Check(other)) {
-                                typenum = self->descr->type_num;
-                                if (typenum != PyArray_OBJECT) {
-                                        typenum = PyArray_NOTYPE;
-                                }
-                                array_other = PyArray_FromObject(other,
-                                                                 typenum, 0, 0);
-                                /* If not successful, then return False
-                                   This fixes code that used to
-                                   allow equality comparisons between arrays
-                                   and other objects which would give a result
-                                   of False
-                                */
-                                if ((array_other == NULL) ||    \
-                                    (array_other == Py_None)) {
-                                        Py_XDECREF(array_other);
-                                        PyErr_Clear();
-                                        Py_INCREF(Py_False);
-                                        return Py_False;
-                                }
-                        }
-                        else {
-                                Py_INCREF(other);
-                                array_other = other;
-                        }
-                        result = PyArray_GenericBinaryFunction(self,
-                                                               array_other,
-                                                               n_ops.equal);
-                        if ((result == Py_NotImplemented) &&
-                            (self->descr->type_num == PyArray_VOID)) {
-                                int _res;
-                                _res = PyObject_RichCompareBool \
-                                        ((PyObject *)self->descr,
-                                         (PyObject *)\
-                                         PyArray_DESCR(array_other),
-                                         Py_EQ);
-                                if (_res < 0) {
-                                        Py_DECREF(result);
-                                        Py_DECREF(array_other);
-                                        return NULL;
-                                }
-                                if (_res) {
-                                        Py_DECREF(result);
-                                        result = _void_compare\
-                                                (self,
-                                                 (PyArrayObject *)array_other,
-                                                 cmp_op);
-                                        Py_DECREF(array_other);
-                                }
-                                return result;
-                        }
-                        /* If the comparison results in NULL, then the
-                           two array objects can not be compared together so
-                           return zero
-                        */
-                        Py_DECREF(array_other);
-                        if (result == NULL) {
-                                PyErr_Clear();
-                                Py_INCREF(Py_False);
-                                return Py_False;
-                        }
-                        break;
-                case Py_NE:
-                        if (other == Py_None) {
-                                Py_INCREF(Py_True);
-                                return Py_True;
-                        }
-                        /* Try to convert other to an array */
-                        if (!PyArray_Check(other)) {
-                                typenum = self->descr->type_num;
-                                if (typenum != PyArray_OBJECT) {
-                                        typenum = PyArray_NOTYPE;
-                                }
-                                array_other = PyArray_FromObject(other,
-                                                                 typenum, 0, 0);
-                                /* If not successful, then objects cannot be
-                                   compared and cannot be equal, therefore,
-                                   return True;
-                                */
-                                if ((array_other == NULL) ||    \
-                                    (array_other == Py_None)) {
-                                        Py_XDECREF(array_other);
-                                        PyErr_Clear();
-                                        Py_INCREF(Py_True);
-                                        return Py_True;
-                                }
-                        }
-                        else {
-                                Py_INCREF(other);
-                                array_other = other;
-                        }
-                        result = PyArray_GenericBinaryFunction(self,
-                                                               array_other,
-                                                               n_ops.not_equal);
-                        if ((result == Py_NotImplemented) &&
-                            (self->descr->type_num == PyArray_VOID)) {
-                                int _res;
-                                _res = PyObject_RichCompareBool\
-                                        ((PyObject *)self->descr,
-                                         (PyObject *)\
-                                         PyArray_DESCR(array_other),
-                                         Py_EQ);
-                                if (_res < 0) {
-                                        Py_DECREF(result);
-                                        Py_DECREF(array_other);
-                                        return NULL;
-                                }
-                                if (_res) {
-                                        Py_DECREF(result);
-                                        result = _void_compare\
-                                                (self,
-                                                 (PyArrayObject *)array_other,
-                                                 cmp_op);
-                                        Py_DECREF(array_other);
-                                }
-                                return result;
-                        }
-
-                        Py_DECREF(array_other);
-                        if (result == NULL) {
-                                PyErr_Clear();
-                                Py_INCREF(Py_True);
-                                return Py_True;
-                        }
-                        break;
-                case Py_GT:
-                        result = PyArray_GenericBinaryFunction(self, other,
-                                                               n_ops.greater);
-                        break;
-                case Py_GE:
-                        result = PyArray_GenericBinaryFunction(self, other,
-                                                               n_ops.greater_equal);
-                        break;
-                default:
-                        result = Py_NotImplemented;
-                        Py_INCREF(result);
+    PyObject *array_other, *result = NULL;
+    int typenum;
+
+    switch (cmp_op)
+        {
+        case Py_LT:
+            result = PyArray_GenericBinaryFunction(self, other,
+                                                   n_ops.less);
+            break;
+        case Py_LE:
+            result = PyArray_GenericBinaryFunction(self, other,
+                                                   n_ops.less_equal);
+            break;
+        case Py_EQ:
+            if (other == Py_None) {
+                Py_INCREF(Py_False);
+                return Py_False;
+            }
+            /* Try to convert other to an array */
+            if (!PyArray_Check(other)) {
+                typenum = self->descr->type_num;
+                if (typenum != PyArray_OBJECT) {
+                    typenum = PyArray_NOTYPE;
+                }
+                array_other = PyArray_FromObject(other,
+                                                 typenum, 0, 0);
+                /* If not successful, then return False
+                   This fixes code that used to
+                   allow equality comparisons between arrays
+                   and other objects which would give a result
+                   of False
+                */
+                if ((array_other == NULL) ||    \
+                    (array_other == Py_None)) {
+                    Py_XDECREF(array_other);
+                    PyErr_Clear();
+                    Py_INCREF(Py_False);
+                    return Py_False;
                 }
-        if (result == Py_NotImplemented) {
-                /* Try to handle string comparisons */
-                if (self->descr->type_num == PyArray_OBJECT) return result;
-                array_other = PyArray_FromObject(other,PyArray_NOTYPE, 0, 0);
-                if (PyArray_ISSTRING(self) && PyArray_ISSTRING(array_other)) {
-                        Py_DECREF(result);
-                        result = _strings_richcompare(self, (PyArrayObject *)
-                                                      array_other, cmp_op, 0);
+            }
+            else {
+                Py_INCREF(other);
+                array_other = other;
+            }
+            result = PyArray_GenericBinaryFunction(self,
+                                                   array_other,
+                                                   n_ops.equal);
+            if ((result == Py_NotImplemented) &&
+                (self->descr->type_num == PyArray_VOID)) {
+                int _res;
+                _res = PyObject_RichCompareBool \
+                    ((PyObject *)self->descr,
+                     (PyObject *)\
+                     PyArray_DESCR(array_other),
+                     Py_EQ);
+                if (_res < 0) {
+                    Py_DECREF(result);
+                    Py_DECREF(array_other);
+                    return NULL;
+                }
+                if (_res) {
+                    Py_DECREF(result);
+                    result = _void_compare\
+                        (self,
+                         (PyArrayObject *)array_other,
+                         cmp_op);
+                    Py_DECREF(array_other);
+                }
+                return result;
+            }
+            /* If the comparison results in NULL, then the
+               two array objects can not be compared together so
+               return zero
+            */
+            Py_DECREF(array_other);
+            if (result == NULL) {
+                PyErr_Clear();
+                Py_INCREF(Py_False);
+                return Py_False;
+            }
+            break;
+        case Py_NE:
+            if (other == Py_None) {
+                Py_INCREF(Py_True);
+                return Py_True;
+            }
+            /* Try to convert other to an array */
+            if (!PyArray_Check(other)) {
+                typenum = self->descr->type_num;
+                if (typenum != PyArray_OBJECT) {
+                    typenum = PyArray_NOTYPE;
+                }
+                array_other = PyArray_FromObject(other,
+                                                 typenum, 0, 0);
+                /* If not successful, then objects cannot be
+                   compared and cannot be equal, therefore,
+                   return True;
+                */
+                if ((array_other == NULL) ||    \
+                    (array_other == Py_None)) {
+                    Py_XDECREF(array_other);
+                    PyErr_Clear();
+                    Py_INCREF(Py_True);
+                    return Py_True;
                 }
-                Py_DECREF(array_other);
-        }
-        return result;
+            }
+            else {
+                Py_INCREF(other);
+                array_other = other;
+            }
+            result = PyArray_GenericBinaryFunction(self,
+                                                   array_other,
+                                                   n_ops.not_equal);
+            if ((result == Py_NotImplemented) &&
+                (self->descr->type_num == PyArray_VOID)) {
+                int _res;
+                _res = PyObject_RichCompareBool\
+                    ((PyObject *)self->descr,
+                     (PyObject *)\
+                     PyArray_DESCR(array_other),
+                     Py_EQ);
+                if (_res < 0) {
+                    Py_DECREF(result);
+                    Py_DECREF(array_other);
+                    return NULL;
+                }
+                if (_res) {
+                    Py_DECREF(result);
+                    result = _void_compare\
+                        (self,
+                         (PyArrayObject *)array_other,
+                         cmp_op);
+                    Py_DECREF(array_other);
+                }
+                return result;
+            }
+
+            Py_DECREF(array_other);
+            if (result == NULL) {
+                PyErr_Clear();
+                Py_INCREF(Py_True);
+                return Py_True;
+            }
+            break;
+        case Py_GT:
+            result = PyArray_GenericBinaryFunction(self, other,
+                                                   n_ops.greater);
+            break;
+        case Py_GE:
+            result = PyArray_GenericBinaryFunction(self, other,
+                                                   n_ops.greater_equal);
+            break;
+        default:
+            result = Py_NotImplemented;
+            Py_INCREF(result);
+        }
+    if (result == Py_NotImplemented) {
+        /* Try to handle string comparisons */
+        if (self->descr->type_num == PyArray_OBJECT) return result;
+        array_other = PyArray_FromObject(other,PyArray_NOTYPE, 0, 0);
+        if (PyArray_ISSTRING(self) && PyArray_ISSTRING(array_other)) {
+            Py_DECREF(result);
+            result = _strings_richcompare(self, (PyArrayObject *)
+                                          array_other, cmp_op, 0);
+        }
+        Py_DECREF(array_other);
+    }
+    return result;
 }
 
 static PyObject *
 _check_axis(PyArrayObject *arr, int *axis, int flags)
 {
-        PyObject *temp1, *temp2;
-        int n = arr->nd;
+    PyObject *temp1, *temp2;
+    int n = arr->nd;
 
-        if ((*axis >= MAX_DIMS) || (n==0)) {
-                if (n != 1) {
-                        temp1 = PyArray_Ravel(arr,0);
-                        if (temp1 == NULL) {*axis=0; return NULL;}
-                        *axis = PyArray_NDIM(temp1)-1;
-                }
-                else {
-                        temp1 = (PyObject *)arr;
-                        Py_INCREF(temp1);
-                        *axis = 0;
-                }
-                if (!flags) return temp1;
-        }
-        else {
-                temp1 = (PyObject *)arr;
-                Py_INCREF(temp1);
-        }
-        if (flags) {
-                temp2 = PyArray_CheckFromAny((PyObject *)temp1, NULL,
-                                             0, 0, flags, NULL);
-                Py_DECREF(temp1);
-                if (temp2 == NULL) return NULL;
+    if ((*axis >= MAX_DIMS) || (n==0)) {
+        if (n != 1) {
+            temp1 = PyArray_Ravel(arr,0);
+            if (temp1 == NULL) {*axis=0; return NULL;}
+            *axis = PyArray_NDIM(temp1)-1;
         }
         else {
-                temp2 = (PyObject *)temp1;
-        }
-        n = PyArray_NDIM(temp2);
-        if (*axis < 0) *axis += n;
-        if ((*axis < 0) || (*axis >= n)) {
-                PyErr_Format(PyExc_ValueError,
-                             "axis(=%d) out of bounds", *axis);
-                Py_DECREF(temp2);
-                return NULL;
+            temp1 = (PyObject *)arr;
+            Py_INCREF(temp1);
+            *axis = 0;
         }
-        return temp2;
+        if (!flags) return temp1;
+    }
+    else {
+        temp1 = (PyObject *)arr;
+        Py_INCREF(temp1);
+    }
+    if (flags) {
+        temp2 = PyArray_CheckFromAny((PyObject *)temp1, NULL,
+                                     0, 0, flags, NULL);
+        Py_DECREF(temp1);
+        if (temp2 == NULL) return NULL;
+    }
+    else {
+        temp2 = (PyObject *)temp1;
+    }
+    n = PyArray_NDIM(temp2);
+    if (*axis < 0) *axis += n;
+    if ((*axis < 0) || (*axis >= n)) {
+        PyErr_Format(PyExc_ValueError,
+                     "axis(=%d) out of bounds", *axis);
+        Py_DECREF(temp2);
+        return NULL;
+    }
+    return temp2;
 }
 
 #include "arraymethods.c"
 
 /* Lifted from numarray */
 /*MULTIARRAY_API
- PyArray_IntTupleFromIntp
+  PyArray_IntTupleFromIntp
 */
 static PyObject *
 PyArray_IntTupleFromIntp(int len, intp *vals)
 {
-        int i;
-        PyObject *intTuple = PyTuple_New(len);
-        if (!intTuple) goto fail;
-        for(i=0; i<len; i++) {
+    int i;
+    PyObject *intTuple = PyTuple_New(len);
+    if (!intTuple) goto fail;
+    for(i=0; i<len; i++) {
 #if SIZEOF_INTP <= SIZEOF_LONG
-                PyObject *o = PyInt_FromLong((long) vals[i]);
+        PyObject *o = PyInt_FromLong((long) vals[i]);
 #else
-                PyObject *o = PyLong_FromLongLong((longlong) vals[i]);
+        PyObject *o = PyLong_FromLongLong((longlong) vals[i]);
 #endif
-                if (!o) {
-                        Py_DECREF(intTuple);
-                        intTuple = NULL;
-                        goto fail;
-                }
-                PyTuple_SET_ITEM(intTuple, i, o);
+        if (!o) {
+            Py_DECREF(intTuple);
+            intTuple = NULL;
+            goto fail;
         }
-  fail:
-        return intTuple;
+        PyTuple_SET_ITEM(intTuple, i, o);
+    }
+ fail:
+    return intTuple;
 }
 
 /* Returns the number of dimensions or -1 if an error occurred */
 /*  vals must be large enough to hold maxvals */
 /*MULTIARRAY_API
- PyArray_IntpFromSequence
+  PyArray_IntpFromSequence
 */
 static int
 PyArray_IntpFromSequence(PyObject *seq, intp *vals, int maxvals)
 {
-        int nd, i;
-        PyObject *op;
+    int nd, i;
+    PyObject *op;
 
-        /* Check to see if sequence is a single integer first.
-             or, can be made into one */
-        if ((nd=PySequence_Length(seq)) == -1) {
-                if (PyErr_Occurred()) PyErr_Clear();
+    /* Check to see if sequence is a single integer first.
+       or, can be made into one */
+    if ((nd=PySequence_Length(seq)) == -1) {
+        if (PyErr_Occurred()) PyErr_Clear();
 #if SIZEOF_LONG >= SIZEOF_INTP
-                if (!(op = PyNumber_Int(seq))) return -1;
+        if (!(op = PyNumber_Int(seq))) return -1;
 #else
-                if (!(op = PyNumber_Long(seq))) return -1;
+        if (!(op = PyNumber_Long(seq))) return -1;
 #endif
-                nd = 1;
+        nd = 1;
 #if SIZEOF_LONG >= SIZEOF_INTP
-                vals[0] = (intp ) PyInt_AsLong(op);
+        vals[0] = (intp ) PyInt_AsLong(op);
 #else
-                vals[0] = (intp ) PyLong_AsLongLong(op);
+        vals[0] = (intp ) PyLong_AsLongLong(op);
 #endif
-                Py_DECREF(op);
-        } else {
-                for(i=0; i < MIN(nd,maxvals); i++) {
-                        op = PySequence_GetItem(seq, i);
-                        if (op == NULL) return -1;
+        Py_DECREF(op);
+    } else {
+        for(i=0; i < MIN(nd,maxvals); i++) {
+            op = PySequence_GetItem(seq, i);
+            if (op == NULL) return -1;
 #if SIZEOF_LONG >= SIZEOF_INTP
-                        vals[i]=(intp )PyInt_AsLong(op);
+            vals[i]=(intp )PyInt_AsLong(op);
 #else
-                        vals[i]=(intp )PyLong_AsLongLong(op);
+            vals[i]=(intp )PyLong_AsLongLong(op);
 #endif
-                        Py_DECREF(op);
-                        if(PyErr_Occurred()) return -1;
-                }
+            Py_DECREF(op);
+            if(PyErr_Occurred()) return -1;
         }
-        return nd;
+    }
+    return nd;
 }
 
 
@@ -4961,22 +4960,22 @@ PyArray_IntpFromSequence(PyObject *seq, intp *vals, int maxvals)
 static int
 _IsContiguous(PyArrayObject *ap)
 {
-        register intp sd;
-        register intp dim;
-        register int i;
-
-        if (ap->nd == 0) return 1;
-        sd = ap->descr->elsize;
-        if (ap->nd == 1) return (ap->dimensions[0] == 1 || \
-                                 sd == ap->strides[0]);
-        for (i = ap->nd-1; i >= 0; --i) {
-                dim = ap->dimensions[i];
-                /* contiguous by definition */
-                if (dim == 0) return 1;
-                if (ap->strides[i] != sd) return 0;
-                sd *= dim;
-        }
-        return 1;
+    register intp sd;
+    register intp dim;
+    register int i;
+
+    if (ap->nd == 0) return 1;
+    sd = ap->descr->elsize;
+    if (ap->nd == 1) return (ap->dimensions[0] == 1 || \
+                             sd == ap->strides[0]);
+    for (i = ap->nd-1; i >= 0; --i) {
+        dim = ap->dimensions[i];
+        /* contiguous by definition */
+        if (dim == 0) return 1;
+        if (ap->strides[i] != sd) return 0;
+        sd *= dim;
+    }
+    return 1;
 }
 
 
@@ -4984,78 +4983,78 @@ _IsContiguous(PyArrayObject *ap)
 static int
 _IsFortranContiguous(PyArrayObject *ap)
 {
-        register intp sd;
-        register intp dim;
-        register int i;
-
-        if (ap->nd == 0) return 1;
-        sd = ap->descr->elsize;
-        if (ap->nd == 1) return (ap->dimensions[0] == 1 || \
-                                 sd == ap->strides[0]);
-        for (i=0; i< ap->nd; ++i) {
-                dim = ap->dimensions[i];
-                /* fortran contiguous by definition */
-                if (dim == 0) return 1;
-                if (ap->strides[i] != sd) return 0;
-                sd *= dim;
-        }
-        return 1;
+    register intp sd;
+    register intp dim;
+    register int i;
+
+    if (ap->nd == 0) return 1;
+    sd = ap->descr->elsize;
+    if (ap->nd == 1) return (ap->dimensions[0] == 1 || \
+                             sd == ap->strides[0]);
+    for (i=0; i< ap->nd; ++i) {
+        dim = ap->dimensions[i];
+        /* fortran contiguous by definition */
+        if (dim == 0) return 1;
+        if (ap->strides[i] != sd) return 0;
+        sd *= dim;
+    }
+    return 1;
 }
 
 static int
 _IsAligned(PyArrayObject *ap)
 {
-        int i, alignment, aligned=1;
-        intp ptr;
-        int type = ap->descr->type_num;
+    int i, alignment, aligned=1;
+    intp ptr;
+    int type = ap->descr->type_num;
 
-        if ((type == PyArray_STRING) || (type == PyArray_VOID))
-                return 1;
+    if ((type == PyArray_STRING) || (type == PyArray_VOID))
+        return 1;
 
-        alignment = ap->descr->alignment;
-        if (alignment == 1) return 1;
+    alignment = ap->descr->alignment;
+    if (alignment == 1) return 1;
 
-        ptr = (intp) ap->data;
-        aligned = (ptr % alignment) == 0;
-        for (i=0; i <ap->nd; i++)
-                aligned &= ((ap->strides[i] % alignment) == 0);
-        return aligned != 0;
+    ptr = (intp) ap->data;
+    aligned = (ptr % alignment) == 0;
+    for (i=0; i <ap->nd; i++)
+        aligned &= ((ap->strides[i] % alignment) == 0);
+    return aligned != 0;
 }
 
 static Bool
 _IsWriteable(PyArrayObject *ap)
 {
-        PyObject *base=ap->base;
-        void *dummy;
-        Py_ssize_t n;
-
-        /* If we own our own data, then no-problem */
-        if ((base == NULL) || (ap->flags & OWNDATA)) return TRUE;
-
-        /* Get to the final base object
-           If it is a writeable array, then return TRUE
-           If we can find an array object
-           or a writeable buffer object as the final base object
-           or a string object (for pickling support memory savings).
-             - this last could be removed if a proper pickleable
-               buffer was added to Python.
-        */
-
-        while(PyArray_Check(base)) {
-                if (PyArray_CHKFLAGS(base, OWNDATA))
-                        return (Bool) (PyArray_ISWRITEABLE(base));
-                base = PyArray_BASE(base);
-        }
+    PyObject *base=ap->base;
+    void *dummy;
+    Py_ssize_t n;
+
+    /* If we own our own data, then no-problem */
+    if ((base == NULL) || (ap->flags & OWNDATA)) return TRUE;
+
+    /* Get to the final base object
+       If it is a writeable array, then return TRUE
+       If we can find an array object
+       or a writeable buffer object as the final base object
+       or a string object (for pickling support memory savings).
+       - this last could be removed if a proper pickleable
+       buffer was added to Python.
+    */
+
+    while(PyArray_Check(base)) {
+        if (PyArray_CHKFLAGS(base, OWNDATA))
+            return (Bool) (PyArray_ISWRITEABLE(base));
+        base = PyArray_BASE(base);
+    }
 
-        /* here so pickle support works seamlessly
-           and unpickled array can be set and reset writeable
-           -- could be abused -- */
-        if PyString_Check(base) return TRUE;
+    /* here so pickle support works seamlessly
+       and unpickled array can be set and reset writeable
+       -- could be abused -- */
+    if PyString_Check(base) return TRUE;
 
-        if (PyObject_AsWriteBuffer(base, &dummy, &n) < 0)
-                return FALSE;
+    if (PyObject_AsWriteBuffer(base, &dummy, &n) < 0)
+        return FALSE;
 
-        return TRUE;
+    return TRUE;
 }
 
 
@@ -5064,49 +5063,49 @@ _IsWriteable(PyArrayObject *ap)
 static int
 PyArray_ElementStrides(PyObject *arr)
 {
-        register int itemsize = PyArray_ITEMSIZE(arr);
-        register int i, N=PyArray_NDIM(arr);
-        register intp *strides = PyArray_STRIDES(arr);
+    register int itemsize = PyArray_ITEMSIZE(arr);
+    register int i, N=PyArray_NDIM(arr);
+    register intp *strides = PyArray_STRIDES(arr);
 
-        for (i=0; i<N; i++) {
-                if ((strides[i] % itemsize) != 0) return 0;
-        }
+    for (i=0; i<N; i++) {
+        if ((strides[i] % itemsize) != 0) return 0;
+    }
 
-        return 1;
+    return 1;
 }
 
 /*OBJECT_API
- Update Several Flags at once.
+  Update Several Flags at once.
 */
 static void
 PyArray_UpdateFlags(PyArrayObject *ret, int flagmask)
 {
 
-        if (flagmask & FORTRAN) {
-                if (_IsFortranContiguous(ret)) {
-                        ret->flags |= FORTRAN;
-                        if (ret->nd > 1) ret->flags &= ~CONTIGUOUS;
-                }
-                else ret->flags &= ~FORTRAN;
-        }
-        if (flagmask & CONTIGUOUS) {
-                if (_IsContiguous(ret)) {
-                        ret->flags |= CONTIGUOUS;
-                        if (ret->nd > 1) ret->flags &= ~FORTRAN;
-                }
-                else ret->flags &= ~CONTIGUOUS;
-        }
-        if (flagmask & ALIGNED) {
-                if (_IsAligned(ret)) ret->flags |= ALIGNED;
-                else ret->flags &= ~ALIGNED;
+    if (flagmask & FORTRAN) {
+        if (_IsFortranContiguous(ret)) {
+            ret->flags |= FORTRAN;
+            if (ret->nd > 1) ret->flags &= ~CONTIGUOUS;
         }
-        /* This is not checked by default WRITEABLE is not
-           part of UPDATE_ALL */
-        if (flagmask & WRITEABLE) {
-                if (_IsWriteable(ret)) ret->flags |= WRITEABLE;
-                else ret->flags &= ~WRITEABLE;
+        else ret->flags &= ~FORTRAN;
+    }
+    if (flagmask & CONTIGUOUS) {
+        if (_IsContiguous(ret)) {
+            ret->flags |= CONTIGUOUS;
+            if (ret->nd > 1) ret->flags &= ~FORTRAN;
         }
-        return;
+        else ret->flags &= ~CONTIGUOUS;
+    }
+    if (flagmask & ALIGNED) {
+        if (_IsAligned(ret)) ret->flags |= ALIGNED;
+        else ret->flags &= ~ALIGNED;
+    }
+    /* This is not checked by default WRITEABLE is not
+       part of UPDATE_ALL */
+    if (flagmask & WRITEABLE) {
+        if (_IsWriteable(ret)) ret->flags |= WRITEABLE;
+        else ret->flags &= ~WRITEABLE;
+    }
+    return;
 }
 
 /* This routine checks to see if newstrides (of length nd) will not
@@ -5130,22 +5129,22 @@ static Bool
 PyArray_CheckStrides(int elsize, int nd, intp numbytes, intp offset,
                      intp *dims, intp *newstrides)
 {
-        int i;
-        intp byte_begin;
-        intp begin;
-        intp end;
+    int i;
+    intp byte_begin;
+    intp begin;
+    intp end;
 
-        if (numbytes == 0)
-                numbytes = PyArray_MultiplyList(dims, nd) * elsize;
+    if (numbytes == 0)
+        numbytes = PyArray_MultiplyList(dims, nd) * elsize;
 
-        begin = -offset;
-        end = numbytes - offset - elsize;
-        for (i=0; i<nd; i++) {
-                byte_begin = newstrides[i]*(dims[i]-1);
-                if ((byte_begin < begin) || (byte_begin > end))
-                        return FALSE;
-        }
-        return TRUE;
+    begin = -offset;
+    end = numbytes - offset - elsize;
+    for (i=0; i<nd; i++) {
+        byte_begin = newstrides[i]*(dims[i]-1);
+        if ((byte_begin < begin) || (byte_begin > end))
+            return FALSE;
+    }
+    return TRUE;
 
 }
 
@@ -5170,55 +5169,55 @@ static size_t
 _array_fill_strides(intp *strides, intp *dims, int nd, size_t itemsize,
                     int inflag, int *objflags)
 {
-        int i;
-        /* Only make Fortran strides if not contiguous as well */
-        if ((inflag & FORTRAN) && !(inflag & CONTIGUOUS)) {
-                for (i=0; i<nd; i++) {
-                        strides[i] = itemsize;
-                        itemsize *= dims[i] ? dims[i] : 1;
-                }
-                *objflags |= FORTRAN;
-                if (nd > 1) *objflags &= ~CONTIGUOUS;
-                else *objflags |= CONTIGUOUS;
-        }
-        else {
-                for (i=nd-1;i>=0;i--) {
-                        strides[i] = itemsize;
-                        itemsize *= dims[i] ? dims[i] : 1;
-                }
-                *objflags |= CONTIGUOUS;
-                if (nd > 1) *objflags &= ~FORTRAN;
-                else *objflags |= FORTRAN;
+    int i;
+    /* Only make Fortran strides if not contiguous as well */
+    if ((inflag & FORTRAN) && !(inflag & CONTIGUOUS)) {
+        for (i=0; i<nd; i++) {
+            strides[i] = itemsize;
+            itemsize *= dims[i] ? dims[i] : 1;
         }
-        return itemsize;
+        *objflags |= FORTRAN;
+        if (nd > 1) *objflags &= ~CONTIGUOUS;
+        else *objflags |= CONTIGUOUS;
+    }
+    else {
+        for (i=nd-1;i>=0;i--) {
+            strides[i] = itemsize;
+            itemsize *= dims[i] ? dims[i] : 1;
+        }
+        *objflags |= CONTIGUOUS;
+        if (nd > 1) *objflags &= ~FORTRAN;
+        else *objflags |= FORTRAN;
+    }
+    return itemsize;
 }
 
 /*OBJECT_API
- Generic new array creation routine.
+  Generic new array creation routine.
 */
 static PyObject *
 PyArray_New(PyTypeObject *subtype, int nd, intp *dims, int type_num,
             intp *strides, void *data, int itemsize, int flags,
             PyObject *obj)
 {
-        PyArray_Descr *descr;
-        PyObject *new;
+    PyArray_Descr *descr;
+    PyObject *new;
 
-        descr = PyArray_DescrFromType(type_num);
-        if (descr == NULL) return NULL;
-        if (descr->elsize == 0) {
-                if (itemsize < 1) {
-                        PyErr_SetString(PyExc_ValueError,
-                                        "data type must provide an itemsize");
-                        Py_DECREF(descr);
-                        return NULL;
-                }
-                PyArray_DESCR_REPLACE(descr);
-                descr->elsize = itemsize;
+    descr = PyArray_DescrFromType(type_num);
+    if (descr == NULL) return NULL;
+    if (descr->elsize == 0) {
+        if (itemsize < 1) {
+            PyErr_SetString(PyExc_ValueError,
+                            "data type must provide an itemsize");
+            Py_DECREF(descr);
+            return NULL;
         }
-        new = PyArray_NewFromDescr(subtype, descr, nd, dims, strides,
-                                   data, flags, obj);
-        return new;
+        PyArray_DESCR_REPLACE(descr);
+        descr->elsize = itemsize;
+    }
+    new = PyArray_NewFromDescr(subtype, descr, nd, dims, strides,
+                               data, flags, obj);
+    return new;
 }
 
 /* Change a sub-array field to the base descriptor */
@@ -5233,462 +5232,462 @@ static int
 _update_descr_and_dimensions(PyArray_Descr **des, intp *newdims,
                              intp *newstrides, int oldnd, int isfortran)
 {
-        PyArray_Descr *old;
-        int newnd;
-        int numnew;
-        intp *mydim;
-        int i;
-        int tuple;
+    PyArray_Descr *old;
+    int newnd;
+    int numnew;
+    intp *mydim;
+    int i;
+    int tuple;
 
-        old = *des;
-        *des = old->subarray->base;
+    old = *des;
+    *des = old->subarray->base;
 
 
-        mydim = newdims + oldnd;
-        tuple = PyTuple_Check(old->subarray->shape);
-        if (tuple) {
-                numnew = PyTuple_GET_SIZE(old->subarray->shape);
-        }
-        else {
-                numnew = 1;
-        }
+    mydim = newdims + oldnd;
+    tuple = PyTuple_Check(old->subarray->shape);
+    if (tuple) {
+        numnew = PyTuple_GET_SIZE(old->subarray->shape);
+    }
+    else {
+        numnew = 1;
+    }
 
 
-        newnd = oldnd + numnew;
-        if (newnd > MAX_DIMS) goto finish;
-        if (isfortran) {
-                memmove(newdims+numnew, newdims, oldnd*sizeof(intp));
-                mydim = newdims;
-        }
+    newnd = oldnd + numnew;
+    if (newnd > MAX_DIMS) goto finish;
+    if (isfortran) {
+        memmove(newdims+numnew, newdims, oldnd*sizeof(intp));
+        mydim = newdims;
+    }
 
-        if (tuple) {
-                for (i=0; i<numnew; i++) {
-                        mydim[i] = (intp) PyInt_AsLong                  \
-                                (PyTuple_GET_ITEM(old->subarray->shape, i));
-                }
-        }
-        else {
-                mydim[0] = (intp) PyInt_AsLong(old->subarray->shape);
+    if (tuple) {
+        for (i=0; i<numnew; i++) {
+            mydim[i] = (intp) PyInt_AsLong                  \
+                (PyTuple_GET_ITEM(old->subarray->shape, i));
         }
+    }
+    else {
+        mydim[0] = (intp) PyInt_AsLong(old->subarray->shape);
+    }
 
-        if (newstrides) {
-                intp tempsize;
-                intp *mystrides;
-                mystrides = newstrides + oldnd;
-                if (isfortran) {
-                        memmove(newstrides+numnew, newstrides,
-                                oldnd*sizeof(intp));
-                        mystrides = newstrides;
-                }
-                /* Make new strides -- alwasy C-contiguous */
-                tempsize = (*des)->elsize;
-                for (i=numnew-1; i>=0; i--) {
-                        mystrides[i] = tempsize;
-                        tempsize *= mydim[i] ? mydim[i] : 1;
-                }
+    if (newstrides) {
+        intp tempsize;
+        intp *mystrides;
+        mystrides = newstrides + oldnd;
+        if (isfortran) {
+            memmove(newstrides+numnew, newstrides,
+                    oldnd*sizeof(intp));
+            mystrides = newstrides;
+        }
+        /* Make new strides -- alwasy C-contiguous */
+        tempsize = (*des)->elsize;
+        for (i=numnew-1; i>=0; i--) {
+            mystrides[i] = tempsize;
+            tempsize *= mydim[i] ? mydim[i] : 1;
         }
+    }
 
  finish:
-        Py_INCREF(*des);
-        Py_DECREF(old);
-        return newnd;
+    Py_INCREF(*des);
+    Py_DECREF(old);
+    return newnd;
 }
 
 
 /* steals a reference to descr (even on failure) */
 /*OBJECT_API
- Generic new array creation routine.
+  Generic new array creation routine.
 */
 static PyObject *
 PyArray_NewFromDescr(PyTypeObject *subtype, PyArray_Descr *descr, int nd,
                      intp *dims, intp *strides, void *data,
                      int flags, PyObject *obj)
 {
-        PyArrayObject *self;
-        register int i;
-        size_t sd;
-        intp largest;
-        intp size;
-
-        if (descr->subarray) {
-                PyObject *ret;
-                intp newdims[2*MAX_DIMS];
-                intp *newstrides=NULL;
-                int isfortran=0;
-                isfortran = (data && (flags & FORTRAN) && !(flags & CONTIGUOUS)) || \
-                        (!data && flags);
-                memcpy(newdims, dims, nd*sizeof(intp));
-                if (strides) {
-                        newstrides = newdims + MAX_DIMS;
-                        memcpy(newstrides, strides, nd*sizeof(intp));
-                }
-                nd =_update_descr_and_dimensions(&descr, newdims,
-                                                 newstrides, nd, isfortran);
-                ret = PyArray_NewFromDescr(subtype, descr, nd, newdims,
-                                           newstrides,
-                                           data, flags, obj);
-                return ret;
-        }
+    PyArrayObject *self;
+    register int i;
+    size_t sd;
+    intp largest;
+    intp size;
 
-        if (nd < 0) {
-                PyErr_SetString(PyExc_ValueError,
-                                "number of dimensions must be >=0");
-                Py_DECREF(descr);
-                return NULL;
-        }
-        if (nd > MAX_DIMS) {
-                PyErr_Format(PyExc_ValueError,
-                             "maximum number of dimensions is %d", MAX_DIMS);
-                Py_DECREF(descr);
-                return NULL;
-        }
+    if (descr->subarray) {
+        PyObject *ret;
+        intp newdims[2*MAX_DIMS];
+        intp *newstrides=NULL;
+        int isfortran=0;
+        isfortran = (data && (flags & FORTRAN) && !(flags & CONTIGUOUS)) || \
+            (!data && flags);
+        memcpy(newdims, dims, nd*sizeof(intp));
+        if (strides) {
+            newstrides = newdims + MAX_DIMS;
+            memcpy(newstrides, strides, nd*sizeof(intp));
+        }
+        nd =_update_descr_and_dimensions(&descr, newdims,
+                                         newstrides, nd, isfortran);
+        ret = PyArray_NewFromDescr(subtype, descr, nd, newdims,
+                                   newstrides,
+                                   data, flags, obj);
+        return ret;
+    }
 
-        /* Check dimensions */
-        size = 1;
-        sd = (size_t) descr->elsize;
-        if (sd == 0) {
-                if (!PyDataType_ISSTRING(descr)) {
-                        PyErr_SetString(PyExc_ValueError, "Empty data-type");
-                        Py_DECREF(descr);
-                        return NULL;
-                }
-                PyArray_DESCR_REPLACE(descr);
-                if (descr->type_num == NPY_STRING) descr->elsize = 1;
-                else descr->elsize = sizeof(PyArray_UCS4);
-                sd = (size_t) descr->elsize;  
-        }
-        largest = MAX_INTP / sd;
-        for (i=0;i<nd;i++) {
-                if (dims[i] == 0) continue;
-                if (dims[i] < 0) {
-                        PyErr_SetString(PyExc_ValueError,
-                                        "negative dimensions "  \
-                                        "are not allowed");
-                        Py_DECREF(descr);
-                        return NULL;
-                }
-                size *= dims[i];
-                if (size > largest) {
-                        PyErr_SetString(PyExc_ValueError,
-                                        "dimensions too large.");
-                        Py_DECREF(descr);
-                        return NULL;
-                }
-        }
+    if (nd < 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "number of dimensions must be >=0");
+        Py_DECREF(descr);
+        return NULL;
+    }
+    if (nd > MAX_DIMS) {
+        PyErr_Format(PyExc_ValueError,
+                     "maximum number of dimensions is %d", MAX_DIMS);
+        Py_DECREF(descr);
+        return NULL;
+    }
 
-        self = (PyArrayObject *) subtype->tp_alloc(subtype, 0);
-        if (self == NULL) {
-                Py_DECREF(descr);
-                return NULL;
+    /* Check dimensions */
+    size = 1;
+    sd = (size_t) descr->elsize;
+    if (sd == 0) {
+        if (!PyDataType_ISSTRING(descr)) {
+            PyErr_SetString(PyExc_ValueError, "Empty data-type");
+            Py_DECREF(descr);
+            return NULL;
         }
-        self->nd = nd;
-        self->dimensions = NULL;
-        self->data = NULL;
-        if (data == NULL) {
-                self->flags = DEFAULT;
-                if (flags) {
-                        self->flags |= FORTRAN;
-                        if (nd > 1) self->flags &= ~CONTIGUOUS;
-                        flags = FORTRAN;
-                }
+        PyArray_DESCR_REPLACE(descr);
+        if (descr->type_num == NPY_STRING) descr->elsize = 1;
+        else descr->elsize = sizeof(PyArray_UCS4);
+        sd = (size_t) descr->elsize;
+    }
+    largest = MAX_INTP / sd;
+    for (i=0;i<nd;i++) {
+        if (dims[i] == 0) continue;
+        if (dims[i] < 0) {
+            PyErr_SetString(PyExc_ValueError,
+                            "negative dimensions "  \
+                            "are not allowed");
+            Py_DECREF(descr);
+            return NULL;
         }
-        else self->flags = (flags & ~UPDATEIFCOPY);
-
-        self->descr = descr;
-        self->base = (PyObject *)NULL;
-        self->weakreflist = (PyObject *)NULL;
-
-        if (nd > 0) {
-                self->dimensions = PyDimMem_NEW(2*nd);
-                if (self->dimensions == NULL) {
-                        PyErr_NoMemory();
-                        goto fail;
-                }
-                self->strides = self->dimensions + nd;
-                memcpy(self->dimensions, dims, sizeof(intp)*nd);
-                if (strides == NULL) { /* fill it in */
-                        sd = _array_fill_strides(self->strides, dims, nd, sd,
-                                                 flags, &(self->flags));
-                }
-                else { /* we allow strides even when we create
-                          the memory, but be careful with this...
-                       */
-                        memcpy(self->strides, strides, sizeof(intp)*nd);
-                        sd *= size;
-                }
+        size *= dims[i];
+        if (size > largest) {
+            PyErr_SetString(PyExc_ValueError,
+                            "dimensions too large.");
+            Py_DECREF(descr);
+            return NULL;
         }
-        else { self->dimensions = self->strides = NULL; }
+    }
 
-        if (data == NULL) {
+    self = (PyArrayObject *) subtype->tp_alloc(subtype, 0);
+    if (self == NULL) {
+        Py_DECREF(descr);
+        return NULL;
+    }
+    self->nd = nd;
+    self->dimensions = NULL;
+    self->data = NULL;
+    if (data == NULL) {
+        self->flags = DEFAULT;
+        if (flags) {
+            self->flags |= FORTRAN;
+            if (nd > 1) self->flags &= ~CONTIGUOUS;
+            flags = FORTRAN;
+        }
+    }
+    else self->flags = (flags & ~UPDATEIFCOPY);
+
+    self->descr = descr;
+    self->base = (PyObject *)NULL;
+    self->weakreflist = (PyObject *)NULL;
+
+    if (nd > 0) {
+        self->dimensions = PyDimMem_NEW(2*nd);
+        if (self->dimensions == NULL) {
+            PyErr_NoMemory();
+            goto fail;
+        }
+        self->strides = self->dimensions + nd;
+        memcpy(self->dimensions, dims, sizeof(intp)*nd);
+        if (strides == NULL) { /* fill it in */
+            sd = _array_fill_strides(self->strides, dims, nd, sd,
+                                     flags, &(self->flags));
+        }
+        else { /* we allow strides even when we create
+                  the memory, but be careful with this...
+               */
+            memcpy(self->strides, strides, sizeof(intp)*nd);
+            sd *= size;
+        }
+    }
+    else { self->dimensions = self->strides = NULL; }
 
-                /* Allocate something even for zero-space arrays
-                 e.g. shape=(0,) -- otherwise buffer exposure
-                 (a.data) doesn't work as it should. */
+    if (data == NULL) {
 
-                if (sd==0) sd = descr->elsize;
+        /* Allocate something even for zero-space arrays
+           e.g. shape=(0,) -- otherwise buffer exposure
+           (a.data) doesn't work as it should. */
 
-                if ((data = PyDataMem_NEW(sd))==NULL) {
-                        PyErr_NoMemory();
-                        goto fail;
-                }
-                self->flags |= OWNDATA;
+        if (sd==0) sd = descr->elsize;
 
-                /* It is bad to have unitialized OBJECT pointers */
-                /* which could also be sub-fields of a VOID array */
-                if (PyDataType_FLAGCHK(descr, NPY_NEEDS_INIT)) {
-                        memset(data, 0, sd);
-                }
+        if ((data = PyDataMem_NEW(sd))==NULL) {
+            PyErr_NoMemory();
+            goto fail;
         }
-        else {
-                self->flags &= ~OWNDATA;  /* If data is passed in,
-                                           this object won't own it
-                                           by default.
-                                           Caller must arrange for
-                                           this to be reset if truly
-                                           desired */
-        }
-        self->data = data;
-
-        /* call the __array_finalize__
-           method if a subtype.
-           If obj is NULL, then call method with Py_None
-        */
-        if ((subtype != &PyArray_Type)) {
-                PyObject *res, *func, *args;
-                static PyObject *str=NULL;
+        self->flags |= OWNDATA;
 
-                if (str == NULL) {
-                        str = PyString_InternFromString("__array_finalize__");
-                }
-                func = PyObject_GetAttr((PyObject *)self, str);
-                if (func && func != Py_None) {
-                        if (strides != NULL) { /* did not allocate own data
-                                                  or funny strides */
-                                /* update flags before finalize function */
-                                PyArray_UpdateFlags(self, UPDATE_ALL);
-                        }
-                        if PyCObject_Check(func) { /* A C-function is stored here */
-                                PyArray_FinalizeFunc *cfunc;
-                                cfunc = PyCObject_AsVoidPtr(func);
-                                Py_DECREF(func);
-                                if (cfunc(self, obj) < 0) goto fail;
-                        }
-                        else {
-                                args = PyTuple_New(1);
-                                if (obj == NULL) obj=Py_None;
-                                Py_INCREF(obj);
-                                PyTuple_SET_ITEM(args, 0, obj);
-                                res = PyObject_Call(func, args, NULL);
-                                Py_DECREF(args);
-                                Py_DECREF(func);
-                                if (res == NULL) goto fail;
-                                else Py_DECREF(res);
-                        }
+        /* It is bad to have unitialized OBJECT pointers */
+        /* which could also be sub-fields of a VOID array */
+        if (PyDataType_FLAGCHK(descr, NPY_NEEDS_INIT)) {
+            memset(data, 0, sd);
+        }
+    }
+    else {
+        self->flags &= ~OWNDATA;  /* If data is passed in,
+                                     this object won't own it
+                                     by default.
+                                     Caller must arrange for
+                                     this to be reset if truly
+                                     desired */
+    }
+    self->data = data;
+
+    /* call the __array_finalize__
+       method if a subtype.
+       If obj is NULL, then call method with Py_None
+    */
+    if ((subtype != &PyArray_Type)) {
+        PyObject *res, *func, *args;
+        static PyObject *str=NULL;
+
+        if (str == NULL) {
+            str = PyString_InternFromString("__array_finalize__");
+        }
+        func = PyObject_GetAttr((PyObject *)self, str);
+        if (func && func != Py_None) {
+            if (strides != NULL) { /* did not allocate own data
+                                      or funny strides */
+                /* update flags before finalize function */
+                PyArray_UpdateFlags(self, UPDATE_ALL);
+            }
+            if PyCObject_Check(func) { /* A C-function is stored here */
+                    PyArray_FinalizeFunc *cfunc;
+                    cfunc = PyCObject_AsVoidPtr(func);
+                    Py_DECREF(func);
+                    if (cfunc(self, obj) < 0) goto fail;
                 }
-                else Py_XDECREF(func);
+            else {
+                args = PyTuple_New(1);
+                if (obj == NULL) obj=Py_None;
+                Py_INCREF(obj);
+                PyTuple_SET_ITEM(args, 0, obj);
+                res = PyObject_Call(func, args, NULL);
+                Py_DECREF(args);
+                Py_DECREF(func);
+                if (res == NULL) goto fail;
+                else Py_DECREF(res);
+            }
         }
+        else Py_XDECREF(func);
+    }
 
-        return (PyObject *)self;
+    return (PyObject *)self;
 
  fail:
-        Py_DECREF(self);
-        return NULL;
+    Py_DECREF(self);
+    return NULL;
 }
 
 static void
 _putzero(char *optr, PyObject *zero, PyArray_Descr *dtype)
 {
-        if (!PyDataType_FLAGCHK(dtype, NPY_ITEM_REFCOUNT)) {
-                memset(optr, 0, dtype->elsize);
-        }
-        else if (PyDescr_HASFIELDS(dtype)) {
-                PyObject *key, *value, *title=NULL;
-                PyArray_Descr *new;
-                int offset;
-                Py_ssize_t pos=0;
-                while (PyDict_Next(dtype->fields, &pos, &key, &value)) {
-                        if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
-                                              &title)) return;
-                        _putzero(optr + offset, zero, new);
-                }
-        }
-        else {
-                PyObject **temp;
-                Py_INCREF(zero);
-                temp = (PyObject **)optr;
-                *temp = zero;
+    if (!PyDataType_FLAGCHK(dtype, NPY_ITEM_REFCOUNT)) {
+        memset(optr, 0, dtype->elsize);
+    }
+    else if (PyDescr_HASFIELDS(dtype)) {
+        PyObject *key, *value, *title=NULL;
+        PyArray_Descr *new;
+        int offset;
+        Py_ssize_t pos=0;
+        while (PyDict_Next(dtype->fields, &pos, &key, &value)) {
+            if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
+                                  &title)) return;
+            _putzero(optr + offset, zero, new);
         }
-        return;
+    }
+    else {
+        PyObject **temp;
+        Py_INCREF(zero);
+        temp = (PyObject **)optr;
+        *temp = zero;
+    }
+    return;
 }
 
 
 /*OBJECT_API
- Resize (reallocate data).  Only works if nothing else is referencing
- this array and it is contiguous.
- If refcheck is 0, then the reference count is not checked
- and assumed to be 1.
- You still must own this data and have no weak-references and no base
- object.
+  Resize (reallocate data).  Only works if nothing else is referencing
+  this array and it is contiguous.
+  If refcheck is 0, then the reference count is not checked
+  and assumed to be 1.
+  You still must own this data and have no weak-references and no base
+  object.
 */
 static PyObject *
 PyArray_Resize(PyArrayObject *self, PyArray_Dims *newshape, int refcheck,
                NPY_ORDER fortran)
 {
-        intp oldsize, newsize;
-        int new_nd=newshape->len, k, n, elsize;
-        int refcnt;
-        intp* new_dimensions=newshape->ptr;
-        intp new_strides[MAX_DIMS];
-        size_t sd;
-        intp *dimptr;
-        char *new_data;
-        intp largest;
-
-        if (!PyArray_ISONESEGMENT(self)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "resize only works on single-segment arrays");
-                return NULL;
-        }
+    intp oldsize, newsize;
+    int new_nd=newshape->len, k, n, elsize;
+    int refcnt;
+    intp* new_dimensions=newshape->ptr;
+    intp new_strides[MAX_DIMS];
+    size_t sd;
+    intp *dimptr;
+    char *new_data;
+    intp largest;
+
+    if (!PyArray_ISONESEGMENT(self)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "resize only works on single-segment arrays");
+        return NULL;
+    }
 
-        if (fortran == PyArray_ANYORDER)
-                fortran = PyArray_CORDER;
+    if (fortran == PyArray_ANYORDER)
+        fortran = PyArray_CORDER;
 
-        if (self->descr->elsize == 0) {
-                PyErr_SetString(PyExc_ValueError, "Bad data-type size.");
-                return NULL;
+    if (self->descr->elsize == 0) {
+        PyErr_SetString(PyExc_ValueError, "Bad data-type size.");
+        return NULL;
+    }
+    newsize = 1;
+    largest = MAX_INTP / self->descr->elsize;
+    for (k=0; k<new_nd; k++) {
+        if (new_dimensions[k]==0) break;
+        if (new_dimensions[k] < 0) {
+            PyErr_SetString(PyExc_ValueError,
+                            "negative dimensions not allowed");
+            return NULL;
         }
-        newsize = 1;
-        largest = MAX_INTP / self->descr->elsize;
-        for (k=0; k<new_nd; k++) {
-                if (new_dimensions[k]==0) break;
-                if (new_dimensions[k] < 0) {
-                        PyErr_SetString(PyExc_ValueError,
-                                        "negative dimensions not allowed");
-                        return NULL;
-                }
-                newsize *= new_dimensions[k];
-                if (newsize <=0 || newsize > largest) {
-                        return PyErr_NoMemory();
-                }
+        newsize *= new_dimensions[k];
+        if (newsize <=0 || newsize > largest) {
+            return PyErr_NoMemory();
         }
-        oldsize = PyArray_SIZE(self);
+    }
+    oldsize = PyArray_SIZE(self);
 
-        if (oldsize != newsize) {
-                if (!(self->flags & OWNDATA)) {
-                        PyErr_SetString(PyExc_ValueError,
-                                        "cannot resize this array:  "   \
-                                        "it does not own its data");
-                        return NULL;
-                }
+    if (oldsize != newsize) {
+        if (!(self->flags & OWNDATA)) {
+            PyErr_SetString(PyExc_ValueError,
+                            "cannot resize this array:  "   \
+                            "it does not own its data");
+            return NULL;
+        }
 
-                if (refcheck) refcnt = REFCOUNT(self);
-                else refcnt = 1;
-                if ((refcnt > 2) || (self->base != NULL) ||     \
-                    (self->weakreflist != NULL)) {
-                        PyErr_SetString(PyExc_ValueError,
-                                        "cannot resize an array that has "\
-                                        "been referenced or is referencing\n"\
-                                        "another array in this way.  Use the "\
-                                        "resize function");
-                        return NULL;
-                }
+        if (refcheck) refcnt = REFCOUNT(self);
+        else refcnt = 1;
+        if ((refcnt > 2) || (self->base != NULL) ||     \
+            (self->weakreflist != NULL)) {
+            PyErr_SetString(PyExc_ValueError,
+                            "cannot resize an array that has "\
+                            "been referenced or is referencing\n"\
+                            "another array in this way.  Use the "\
+                            "resize function");
+            return NULL;
+        }
 
-                if (newsize == 0) sd = self->descr->elsize;
-                else sd = newsize * self->descr->elsize;
-                /* Reallocate space if needed */
-                new_data = PyDataMem_RENEW(self->data, sd);
-                if (new_data == NULL) {
-                        PyErr_SetString(PyExc_MemoryError,
-                                        "cannot allocate memory for array");
-                        return NULL;
-                }
-                self->data = new_data;
-        }
-
-        if ((newsize > oldsize) && PyArray_ISWRITEABLE(self)) {
-                /* Fill new memory with zeros */
-                elsize = self->descr->elsize;
-                if (PyDataType_FLAGCHK(self->descr, NPY_ITEM_REFCOUNT)) {
-                        PyObject *zero = PyInt_FromLong(0);
-                        char *optr;
-                        optr = self->data + oldsize*elsize;
-                        n = newsize - oldsize;
-                        for (k=0; k<n; k++) {
-                                _putzero((char *)optr, zero, self->descr);
-                                optr += elsize;
-                        }
-                        Py_DECREF(zero);
-                }
-                else{
-                        memset(self->data+oldsize*elsize, 0,
-                               (newsize-oldsize)*elsize);
-                }
+        if (newsize == 0) sd = self->descr->elsize;
+        else sd = newsize * self->descr->elsize;
+        /* Reallocate space if needed */
+        new_data = PyDataMem_RENEW(self->data, sd);
+        if (new_data == NULL) {
+            PyErr_SetString(PyExc_MemoryError,
+                            "cannot allocate memory for array");
+            return NULL;
         }
+        self->data = new_data;
+    }
 
-        if (self->nd != new_nd) {  /* Different number of dimensions. */
-                self->nd = new_nd;
+    if ((newsize > oldsize) && PyArray_ISWRITEABLE(self)) {
+        /* Fill new memory with zeros */
+        elsize = self->descr->elsize;
+        if (PyDataType_FLAGCHK(self->descr, NPY_ITEM_REFCOUNT)) {
+            PyObject *zero = PyInt_FromLong(0);
+            char *optr;
+            optr = self->data + oldsize*elsize;
+            n = newsize - oldsize;
+            for (k=0; k<n; k++) {
+                _putzero((char *)optr, zero, self->descr);
+                optr += elsize;
+            }
+            Py_DECREF(zero);
+        }
+        else{
+            memset(self->data+oldsize*elsize, 0,
+                   (newsize-oldsize)*elsize);
+        }
+    }
 
-                /* Need new dimensions and strides arrays */
-                dimptr = PyDimMem_RENEW(self->dimensions, 2*new_nd);
-                if (dimptr == NULL) {
-                        PyErr_SetString(PyExc_MemoryError,
-                                        "cannot allocate memory for array " \
-                                        "(array may be corrupted)");
-                        return NULL;
-                }
-                self->dimensions = dimptr;
-                self->strides = dimptr + new_nd;
+    if (self->nd != new_nd) {  /* Different number of dimensions. */
+        self->nd = new_nd;
+
+        /* Need new dimensions and strides arrays */
+        dimptr = PyDimMem_RENEW(self->dimensions, 2*new_nd);
+        if (dimptr == NULL) {
+            PyErr_SetString(PyExc_MemoryError,
+                            "cannot allocate memory for array " \
+                            "(array may be corrupted)");
+            return NULL;
         }
+        self->dimensions = dimptr;
+        self->strides = dimptr + new_nd;
+    }
 
-        /* make new_strides variable */
-        sd = (size_t) self->descr->elsize;
-        sd = (size_t) _array_fill_strides(new_strides, new_dimensions, new_nd, sd,
-                                          self->flags, &(self->flags));
+    /* make new_strides variable */
+    sd = (size_t) self->descr->elsize;
+    sd = (size_t) _array_fill_strides(new_strides, new_dimensions, new_nd, sd,
+                                      self->flags, &(self->flags));
 
-        memmove(self->dimensions, new_dimensions, new_nd*sizeof(intp));
-        memmove(self->strides, new_strides, new_nd*sizeof(intp));
+    memmove(self->dimensions, new_dimensions, new_nd*sizeof(intp));
+    memmove(self->strides, new_strides, new_nd*sizeof(intp));
 
-        Py_INCREF(Py_None);
-        return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 
 }
 
 static void
 _fillobject(char *optr, PyObject *obj, PyArray_Descr *dtype)
 {
-        if (!PyDataType_FLAGCHK(dtype, NPY_ITEM_REFCOUNT)) {
-                if ((obj == Py_None) ||
-                    (PyInt_Check(obj) && PyInt_AsLong(obj)==0))
-                        return;
-                else {
-                        PyObject *arr;
-                        Py_INCREF(dtype);
-                        arr = PyArray_NewFromDescr(&PyArray_Type, dtype,
-                                                   0, NULL, NULL, NULL,
-                                                   0, NULL);
-                        if (arr!=NULL)
-                                dtype->f->setitem(obj, optr, arr);
-                        Py_XDECREF(arr);
-                }
-        }
-        else if (PyDescr_HASFIELDS(dtype)) {
-                PyObject *key, *value, *title=NULL;
-                PyArray_Descr *new;
-                int offset;
-                Py_ssize_t pos=0;
-                while (PyDict_Next(dtype->fields, &pos, &key, &value)) {
-                        if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
-                                              &title)) return;
-                        _fillobject(optr + offset, obj, new);
-                }
-        }
+    if (!PyDataType_FLAGCHK(dtype, NPY_ITEM_REFCOUNT)) {
+        if ((obj == Py_None) ||
+            (PyInt_Check(obj) && PyInt_AsLong(obj)==0))
+            return;
         else {
-                PyObject **temp;
-                Py_XINCREF(obj);
-                temp = (PyObject **)optr;
-                *temp = obj;
-                return;
+            PyObject *arr;
+            Py_INCREF(dtype);
+            arr = PyArray_NewFromDescr(&PyArray_Type, dtype,
+                                       0, NULL, NULL, NULL,
+                                       0, NULL);
+            if (arr!=NULL)
+                dtype->f->setitem(obj, optr, arr);
+            Py_XDECREF(arr);
+        }
+    }
+    else if (PyDescr_HASFIELDS(dtype)) {
+        PyObject *key, *value, *title=NULL;
+        PyArray_Descr *new;
+        int offset;
+        Py_ssize_t pos=0;
+        while (PyDict_Next(dtype->fields, &pos, &key, &value)) {
+            if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
+                                  &title)) return;
+            _fillobject(optr + offset, obj, new);
         }
+    }
+    else {
+        PyObject **temp;
+        Py_XINCREF(obj);
+        temp = (PyObject **)optr;
+        *temp = obj;
+        return;
+    }
 }
 
 /* Assumes contiguous */
@@ -5696,240 +5695,240 @@ _fillobject(char *optr, PyObject *obj, PyArray_Descr *dtype)
 static void
 PyArray_FillObjectArray(PyArrayObject *arr, PyObject *obj)
 {
-        intp i,n;
+    intp i,n;
+    n = PyArray_SIZE(arr);
+    if (arr->descr->type_num == PyArray_OBJECT) {
+        PyObject **optr;
+        optr = (PyObject **)(arr->data);
         n = PyArray_SIZE(arr);
-        if (arr->descr->type_num == PyArray_OBJECT) {
-                PyObject **optr;
-                optr = (PyObject **)(arr->data);
-                n = PyArray_SIZE(arr);
-                if (obj == NULL) {
-                        for (i=0; i<n; i++) {
-                                *optr++ = NULL;
-                        }
-                }
-                else {
-                        for (i=0; i<n; i++) {
-                                Py_INCREF(obj);
-                                *optr++ = obj;
-                        }
-                }
+        if (obj == NULL) {
+            for (i=0; i<n; i++) {
+                *optr++ = NULL;
+            }
         }
         else {
-                char *optr;
-                optr = arr->data;
-                for (i=0; i<n; i++) {
-                        _fillobject(optr, obj, arr->descr);
-                        optr += arr->descr->elsize;
-                }
+            for (i=0; i<n; i++) {
+                Py_INCREF(obj);
+                *optr++ = obj;
+            }
+        }
+    }
+    else {
+        char *optr;
+        optr = arr->data;
+        for (i=0; i<n; i++) {
+            _fillobject(optr, obj, arr->descr);
+            optr += arr->descr->elsize;
         }
+    }
 }
 
 /*OBJECT_API*/
 static int
 PyArray_FillWithScalar(PyArrayObject *arr, PyObject *obj)
 {
-        PyObject *newarr;
-        int itemsize, swap;
-        void *fromptr;
-        PyArray_Descr *descr;
-        intp size;
-        PyArray_CopySwapFunc *copyswap;
-
-        itemsize = arr->descr->elsize;
-        if (PyArray_ISOBJECT(arr)) {
-                fromptr = &obj;
-                swap = 0;
-                newarr = NULL;
+    PyObject *newarr;
+    int itemsize, swap;
+    void *fromptr;
+    PyArray_Descr *descr;
+    intp size;
+    PyArray_CopySwapFunc *copyswap;
+
+    itemsize = arr->descr->elsize;
+    if (PyArray_ISOBJECT(arr)) {
+        fromptr = &obj;
+        swap = 0;
+        newarr = NULL;
+    }
+    else {
+        descr = PyArray_DESCR(arr);
+        Py_INCREF(descr);
+        newarr = PyArray_FromAny(obj, descr, 0,0, ALIGNED, NULL);
+        if (newarr == NULL) return -1;
+        fromptr = PyArray_DATA(newarr);
+        swap=!PyArray_ISNOTSWAPPED(arr);
+    }
+    size=PyArray_SIZE(arr);
+    copyswap = arr->descr->f->copyswap;
+    if (PyArray_ISONESEGMENT(arr)) {
+        char *toptr=PyArray_DATA(arr);
+        PyArray_FillWithScalarFunc* fillwithscalar =
+            arr->descr->f->fillwithscalar;
+        if (fillwithscalar && PyArray_ISALIGNED(arr)) {
+            copyswap(fromptr, NULL, swap, newarr);
+            fillwithscalar(toptr, size, fromptr, arr);
         }
         else {
-                descr = PyArray_DESCR(arr);
-                Py_INCREF(descr);
-                newarr = PyArray_FromAny(obj, descr, 0,0, ALIGNED, NULL);
-                if (newarr == NULL) return -1;
-                fromptr = PyArray_DATA(newarr);
-                swap=!PyArray_ISNOTSWAPPED(arr);
-        }
-        size=PyArray_SIZE(arr);
-        copyswap = arr->descr->f->copyswap;
-        if (PyArray_ISONESEGMENT(arr)) {
-                char *toptr=PyArray_DATA(arr);
-                PyArray_FillWithScalarFunc* fillwithscalar =
-                        arr->descr->f->fillwithscalar;
-                if (fillwithscalar && PyArray_ISALIGNED(arr)) {
-                        copyswap(fromptr, NULL, swap, newarr);
-                        fillwithscalar(toptr, size, fromptr, arr);
-                }
-                else {
-                        while (size--) {
-                                copyswap(toptr, fromptr, swap, arr);
-                                toptr += itemsize;
-                        }
-                }
+            while (size--) {
+                copyswap(toptr, fromptr, swap, arr);
+                toptr += itemsize;
+            }
         }
-        else {
-                PyArrayIterObject *iter;
+    }
+    else {
+        PyArrayIterObject *iter;
 
-                iter = (PyArrayIterObject *)\
-                        PyArray_IterNew((PyObject *)arr);
-                if (iter == NULL) {
-                        Py_XDECREF(newarr);
-                        return -1;
-                }
-                while(size--) {
-                        copyswap(iter->dataptr, fromptr, swap, arr);
-                        PyArray_ITER_NEXT(iter);
-                }
-                Py_DECREF(iter);
+        iter = (PyArrayIterObject *)\
+            PyArray_IterNew((PyObject *)arr);
+        if (iter == NULL) {
+            Py_XDECREF(newarr);
+            return -1;
         }
-        Py_XDECREF(newarr);
-        return 0;
+        while(size--) {
+            copyswap(iter->dataptr, fromptr, swap, arr);
+            PyArray_ITER_NEXT(iter);
+        }
+        Py_DECREF(iter);
+    }
+    Py_XDECREF(newarr);
+    return 0;
 }
 
 static PyObject *
 array_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
 {
-        static char *kwlist[] = {"shape", "dtype", "buffer",
-                                 "offset", "strides",
-                                 "order", NULL};
-        PyArray_Descr *descr=NULL;
-        int itemsize;
-        PyArray_Dims dims = {NULL, 0};
-        PyArray_Dims strides = {NULL, 0};
-        PyArray_Chunk buffer;
-        longlong offset=0;
-        NPY_ORDER order=PyArray_CORDER;
-        int fortran = 0;
-        PyArrayObject *ret;
-
-        buffer.ptr = NULL;
-        /* Usually called with shape and type
-           but can also be called with buffer, strides, and swapped info
-        */
-
-        /* For now, let's just use this to create an empty, contiguous
-           array of a specific type and shape.
-        */
-
-        if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|O&O&LO&O&",
-                                         kwlist, PyArray_IntpConverter,
-                                         &dims,
-                                         PyArray_DescrConverter,
-                                         &descr,
-                                         PyArray_BufferConverter,
-                                         &buffer,
-                                         &offset,
-                                         &PyArray_IntpConverter,
-                                         &strides,
-                                         &PyArray_OrderConverter,
-                                         &order))
-                goto fail;
-
-        if (order == PyArray_FORTRANORDER) fortran = 1;
-
-        if (descr == NULL)
-                descr = PyArray_DescrFromType(PyArray_DEFAULT);
-
-        itemsize = descr->elsize;
+    static char *kwlist[] = {"shape", "dtype", "buffer",
+                             "offset", "strides",
+                             "order", NULL};
+    PyArray_Descr *descr=NULL;
+    int itemsize;
+    PyArray_Dims dims = {NULL, 0};
+    PyArray_Dims strides = {NULL, 0};
+    PyArray_Chunk buffer;
+    longlong offset=0;
+    NPY_ORDER order=PyArray_CORDER;
+    int fortran = 0;
+    PyArrayObject *ret;
+
+    buffer.ptr = NULL;
+    /* Usually called with shape and type
+       but can also be called with buffer, strides, and swapped info
+    */
+
+    /* For now, let's just use this to create an empty, contiguous
+       array of a specific type and shape.
+    */
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|O&O&LO&O&",
+                                     kwlist, PyArray_IntpConverter,
+                                     &dims,
+                                     PyArray_DescrConverter,
+                                     &descr,
+                                     PyArray_BufferConverter,
+                                     &buffer,
+                                     &offset,
+                                     &PyArray_IntpConverter,
+                                     &strides,
+                                     &PyArray_OrderConverter,
+                                     &order))
+        goto fail;
+
+    if (order == PyArray_FORTRANORDER) fortran = 1;
+
+    if (descr == NULL)
+        descr = PyArray_DescrFromType(PyArray_DEFAULT);
+
+    itemsize = descr->elsize;
+
+    if (itemsize == 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "data-type with unspecified variable length");
+        goto fail;
+    }
 
-        if (itemsize == 0) {
-                PyErr_SetString(PyExc_ValueError,
-                                "data-type with unspecified variable length");
-                goto fail;
+    if (strides.ptr != NULL) {
+        intp nb, off;
+        if (strides.len != dims.len) {
+            PyErr_SetString(PyExc_ValueError,
+                            "strides, if given, must be "   \
+                            "the same length as shape");
+            goto fail;
         }
 
-        if (strides.ptr != NULL) {
-                intp nb, off;
-                if (strides.len != dims.len) {
-                        PyErr_SetString(PyExc_ValueError,
-                                        "strides, if given, must be "   \
-                                        "the same length as shape");
-                        goto fail;
-                }
-
-                if (buffer.ptr == NULL) {
-                        nb = 0;
-                        off = 0;
-                }
-                else {
-                        nb = buffer.len;
-                        off = (intp) offset;
-                }
+        if (buffer.ptr == NULL) {
+            nb = 0;
+            off = 0;
+        }
+        else {
+            nb = buffer.len;
+            off = (intp) offset;
+        }
 
 
-                if (!PyArray_CheckStrides(itemsize, dims.len,
-                                          nb, off,
-                                          dims.ptr, strides.ptr)) {
-                        PyErr_SetString(PyExc_ValueError,
-                                        "strides is incompatible "      \
-                                        "with shape of requested "      \
-                                        "array and size of buffer");
-                        goto fail;
-                }
+        if (!PyArray_CheckStrides(itemsize, dims.len,
+                                  nb, off,
+                                  dims.ptr, strides.ptr)) {
+            PyErr_SetString(PyExc_ValueError,
+                            "strides is incompatible "      \
+                            "with shape of requested "      \
+                            "array and size of buffer");
+            goto fail;
         }
+    }
 
-        if (buffer.ptr == NULL) {
-                ret = (PyArrayObject *)                         \
-                        PyArray_NewFromDescr(subtype, descr,
-                                             (int)dims.len,
-                                             dims.ptr,
-                                             strides.ptr, NULL, fortran, NULL);
-                if (ret == NULL) {descr=NULL;goto fail;}
-                if (PyDataType_FLAGCHK(descr, NPY_ITEM_HASOBJECT)) { 
-                        /* place Py_None in object positions */
-                        PyArray_FillObjectArray(ret, Py_None);
-                        if (PyErr_Occurred()) {
-                                descr=NULL;
-                                goto fail;
-                        }
-                }
+    if (buffer.ptr == NULL) {
+        ret = (PyArrayObject *)                         \
+            PyArray_NewFromDescr(subtype, descr,
+                                 (int)dims.len,
+                                 dims.ptr,
+                                 strides.ptr, NULL, fortran, NULL);
+        if (ret == NULL) {descr=NULL;goto fail;}
+        if (PyDataType_FLAGCHK(descr, NPY_ITEM_HASOBJECT)) {
+            /* place Py_None in object positions */
+            PyArray_FillObjectArray(ret, Py_None);
+            if (PyErr_Occurred()) {
+                descr=NULL;
+                goto fail;
+            }
         }
-        else {  /* buffer given -- use it */
-                if (dims.len == 1 && dims.ptr[0] == -1) {
-                        dims.ptr[0] = (buffer.len-(intp)offset) / itemsize;
-                }
-                else if ((strides.ptr == NULL) && \
-                         (buffer.len < ((intp)itemsize)*                \
-                          PyArray_MultiplyList(dims.ptr, dims.len))) {
-                        PyErr_SetString(PyExc_TypeError,
-                                        "buffer is too small for "      \
-                                        "requested array");
-                        goto fail;
-                }
-                /* get writeable and aligned */
-                if (fortran) buffer.flags |= FORTRAN;
-                ret = (PyArrayObject *)\
-                        PyArray_NewFromDescr(subtype, descr,
-                                             dims.len, dims.ptr,
-                                             strides.ptr,
-                                             offset + (char *)buffer.ptr,
-                                             buffer.flags, NULL);
-                if (ret == NULL) {descr=NULL; goto fail;}
-                PyArray_UpdateFlags(ret, UPDATE_ALL);
-                ret->base = buffer.base;
-                Py_INCREF(buffer.base);
-        }
-
-        PyDimMem_FREE(dims.ptr);
-        if (strides.ptr) PyDimMem_FREE(strides.ptr);
-        return (PyObject *)ret;
+    }
+    else {  /* buffer given -- use it */
+        if (dims.len == 1 && dims.ptr[0] == -1) {
+            dims.ptr[0] = (buffer.len-(intp)offset) / itemsize;
+        }
+        else if ((strides.ptr == NULL) && \
+                 (buffer.len < ((intp)itemsize)*                \
+                  PyArray_MultiplyList(dims.ptr, dims.len))) {
+            PyErr_SetString(PyExc_TypeError,
+                            "buffer is too small for "      \
+                            "requested array");
+            goto fail;
+        }
+        /* get writeable and aligned */
+        if (fortran) buffer.flags |= FORTRAN;
+        ret = (PyArrayObject *)\
+            PyArray_NewFromDescr(subtype, descr,
+                                 dims.len, dims.ptr,
+                                 strides.ptr,
+                                 offset + (char *)buffer.ptr,
+                                 buffer.flags, NULL);
+        if (ret == NULL) {descr=NULL; goto fail;}
+        PyArray_UpdateFlags(ret, UPDATE_ALL);
+        ret->base = buffer.base;
+        Py_INCREF(buffer.base);
+    }
+
+    PyDimMem_FREE(dims.ptr);
+    if (strides.ptr) PyDimMem_FREE(strides.ptr);
+    return (PyObject *)ret;
 
  fail:
-        Py_XDECREF(descr);
-        if (dims.ptr) PyDimMem_FREE(dims.ptr);
-        if (strides.ptr) PyDimMem_FREE(strides.ptr);
-        return NULL;
+    Py_XDECREF(descr);
+    if (dims.ptr) PyDimMem_FREE(dims.ptr);
+    if (strides.ptr) PyDimMem_FREE(strides.ptr);
+    return NULL;
 }
 
 
 static PyObject *
 array_iter(PyArrayObject *arr)
 {
-        if (arr->nd == 0) {
-                PyErr_SetString(PyExc_TypeError,
-                                "iteration over a 0-d array");
-                return NULL;
-        }
-        return PySeqIter_New((PyObject *)arr);
+    if (arr->nd == 0) {
+        PyErr_SetString(PyExc_TypeError,
+                        "iteration over a 0-d array");
+        return NULL;
+    }
+    return PySeqIter_New((PyObject *)arr);
 }
 
 
@@ -5938,124 +5937,124 @@ array_iter(PyArrayObject *arr)
 static PyObject *
 array_ndim_get(PyArrayObject *self)
 {
-        return PyInt_FromLong(self->nd);
+    return PyInt_FromLong(self->nd);
 }
 
 static PyObject *
 array_flags_get(PyArrayObject *self)
 {
-        return PyArray_NewFlagsObject((PyObject *)self);
+    return PyArray_NewFlagsObject((PyObject *)self);
 }
 
 static PyObject *
 array_shape_get(PyArrayObject *self)
 {
-        return PyArray_IntTupleFromIntp(self->nd, self->dimensions);
+    return PyArray_IntTupleFromIntp(self->nd, self->dimensions);
 }
 
 
 static int
 array_shape_set(PyArrayObject *self, PyObject *val)
 {
-        int nd;
-        PyObject *ret;
-
-        /* Assumes C-order */
-        ret = PyArray_Reshape(self, val);
-        if (ret == NULL) return -1;
-        if (PyArray_DATA(ret) != PyArray_DATA(self)) {
-                Py_DECREF(ret);
-                PyErr_SetString(PyExc_AttributeError,
-                                "incompatible shape for a non-contiguous "\
-                                "array");
-                return -1;
-        }
+    int nd;
+    PyObject *ret;
 
-        /* Free old dimensions and strides */
-        PyDimMem_FREE(self->dimensions);
-        nd = PyArray_NDIM(ret);
-        self->nd = nd;
-        if (nd > 0) {  /* create new dimensions and strides */
-                self->dimensions = PyDimMem_NEW(2*nd);
-                if (self->dimensions == NULL) {
-                        Py_DECREF(ret);
-                        PyErr_SetString(PyExc_MemoryError,"");
-                        return -1;
-                }
-                self->strides = self->dimensions + nd;
-                memcpy(self->dimensions, PyArray_DIMS(ret),
-                       nd*sizeof(intp));
-                memcpy(self->strides, PyArray_STRIDES(ret),
-                       nd*sizeof(intp));
-        }
-        else {self->dimensions=NULL; self->strides=NULL;}
+    /* Assumes C-order */
+    ret = PyArray_Reshape(self, val);
+    if (ret == NULL) return -1;
+    if (PyArray_DATA(ret) != PyArray_DATA(self)) {
         Py_DECREF(ret);
-        PyArray_UpdateFlags(self, CONTIGUOUS | FORTRAN);
-        return 0;
+        PyErr_SetString(PyExc_AttributeError,
+                        "incompatible shape for a non-contiguous "\
+                        "array");
+        return -1;
+    }
+
+    /* Free old dimensions and strides */
+    PyDimMem_FREE(self->dimensions);
+    nd = PyArray_NDIM(ret);
+    self->nd = nd;
+    if (nd > 0) {  /* create new dimensions and strides */
+        self->dimensions = PyDimMem_NEW(2*nd);
+        if (self->dimensions == NULL) {
+            Py_DECREF(ret);
+            PyErr_SetString(PyExc_MemoryError,"");
+            return -1;
+        }
+        self->strides = self->dimensions + nd;
+        memcpy(self->dimensions, PyArray_DIMS(ret),
+               nd*sizeof(intp));
+        memcpy(self->strides, PyArray_STRIDES(ret),
+               nd*sizeof(intp));
+    }
+    else {self->dimensions=NULL; self->strides=NULL;}
+    Py_DECREF(ret);
+    PyArray_UpdateFlags(self, CONTIGUOUS | FORTRAN);
+    return 0;
 }
 
 
 static PyObject *
 array_strides_get(PyArrayObject *self)
 {
-        return PyArray_IntTupleFromIntp(self->nd, self->strides);
+    return PyArray_IntTupleFromIntp(self->nd, self->strides);
 }
 
 static int
 array_strides_set(PyArrayObject *self, PyObject *obj)
 {
-        PyArray_Dims newstrides = {NULL, 0};
-        PyArrayObject *new;
-        intp numbytes=0;
-        intp offset=0;
-        Py_ssize_t buf_len;
-        char *buf;
-
-        if (!PyArray_IntpConverter(obj, &newstrides) || \
-            newstrides.ptr == NULL) {
-                PyErr_SetString(PyExc_TypeError, "invalid strides");
-                return -1;
-        }
-        if (newstrides.len != self->nd) {
-                PyErr_Format(PyExc_ValueError, "strides must be "       \
-                             " same length as shape (%d)", self->nd);
-                goto fail;
-        }
-        new = self;
-        while(new->base && PyArray_Check(new->base)) {
-                new = (PyArrayObject *)(new->base);
-        }
-        /* Get the available memory through the buffer
-           interface on new->base or if that fails
-           from the current new */
-        if (new->base && PyObject_AsReadBuffer(new->base,
-                                               (const void **)&buf,
-                                               &buf_len) >= 0) {
-                offset = self->data - buf;
-                numbytes = buf_len + offset;
-        }
-        else {
-                PyErr_Clear();
-                numbytes = PyArray_MultiplyList(new->dimensions,
-                                                new->nd)*new->descr->elsize;
-                offset = self->data - new->data;
-        }
+    PyArray_Dims newstrides = {NULL, 0};
+    PyArrayObject *new;
+    intp numbytes=0;
+    intp offset=0;
+    Py_ssize_t buf_len;
+    char *buf;
 
-        if (!PyArray_CheckStrides(self->descr->elsize, self->nd, numbytes,
-                                  offset,
-                                  self->dimensions, newstrides.ptr)) {
-                PyErr_SetString(PyExc_ValueError, "strides is not "\
-                                "compatible with available memory");
-                goto fail;
-        }
-        memcpy(self->strides, newstrides.ptr, sizeof(intp)*newstrides.len);
-        PyArray_UpdateFlags(self, CONTIGUOUS | FORTRAN);
-        PyDimMem_FREE(newstrides.ptr);
-        return 0;
+    if (!PyArray_IntpConverter(obj, &newstrides) || \
+        newstrides.ptr == NULL) {
+        PyErr_SetString(PyExc_TypeError, "invalid strides");
+        return -1;
+    }
+    if (newstrides.len != self->nd) {
+        PyErr_Format(PyExc_ValueError, "strides must be "       \
+                     " same length as shape (%d)", self->nd);
+        goto fail;
+    }
+    new = self;
+    while(new->base && PyArray_Check(new->base)) {
+        new = (PyArrayObject *)(new->base);
+    }
+    /* Get the available memory through the buffer
+       interface on new->base or if that fails
+       from the current new */
+    if (new->base && PyObject_AsReadBuffer(new->base,
+                                           (const void **)&buf,
+                                           &buf_len) >= 0) {
+        offset = self->data - buf;
+        numbytes = buf_len + offset;
+    }
+    else {
+        PyErr_Clear();
+        numbytes = PyArray_MultiplyList(new->dimensions,
+                                        new->nd)*new->descr->elsize;
+        offset = self->data - new->data;
+    }
+
+    if (!PyArray_CheckStrides(self->descr->elsize, self->nd, numbytes,
+                              offset,
+                              self->dimensions, newstrides.ptr)) {
+        PyErr_SetString(PyExc_ValueError, "strides is not "\
+                        "compatible with available memory");
+        goto fail;
+    }
+    memcpy(self->strides, newstrides.ptr, sizeof(intp)*newstrides.len);
+    PyArray_UpdateFlags(self, CONTIGUOUS | FORTRAN);
+    PyDimMem_FREE(newstrides.ptr);
+    return 0;
 
  fail:
-        PyDimMem_FREE(newstrides.ptr);
-        return -1;
+    PyDimMem_FREE(newstrides.ptr);
+    return -1;
 }
 
 
@@ -6063,10 +6062,10 @@ array_strides_set(PyArrayObject *self, PyObject *obj)
 static PyObject *
 array_priority_get(PyArrayObject *self)
 {
-        if (PyArray_CheckExact(self))
-                return PyFloat_FromDouble(PyArray_PRIORITY);
-        else
-                return PyFloat_FromDouble(PyArray_SUBTYPE_PRIORITY);
+    if (PyArray_CheckExact(self))
+        return PyFloat_FromDouble(PyArray_PRIORITY);
+    else
+        return PyFloat_FromDouble(PyArray_SUBTYPE_PRIORITY);
 }
 
 static PyObject *arraydescr_protocol_typestr_get(PyArray_Descr *);
@@ -6074,14 +6073,14 @@ static PyObject *arraydescr_protocol_typestr_get(PyArray_Descr *);
 static PyObject *
 array_typestr_get(PyArrayObject *self)
 {
-        return arraydescr_protocol_typestr_get(self->descr);
+    return arraydescr_protocol_typestr_get(self->descr);
 }
 
 static PyObject *
 array_descr_get(PyArrayObject *self)
 {
-        Py_INCREF(self->descr);
-        return (PyObject *)self->descr;
+    Py_INCREF(self->descr);
+    return (PyObject *)self->descr;
 }
 
 static PyObject *arraydescr_protocol_descr_get(PyArray_Descr *self);
@@ -6089,32 +6088,32 @@ static PyObject *arraydescr_protocol_descr_get(PyArray_Descr *self);
 static PyObject *
 array_protocol_descr_get(PyArrayObject *self)
 {
-        PyObject *res;
-        PyObject *dobj;
+    PyObject *res;
+    PyObject *dobj;
 
-        res = arraydescr_protocol_descr_get(self->descr);
-        if (res) return res;
-        PyErr_Clear();
+    res = arraydescr_protocol_descr_get(self->descr);
+    if (res) return res;
+    PyErr_Clear();
 
-        /* get default */
-        dobj = PyTuple_New(2);
-        if (dobj == NULL) return NULL;
-        PyTuple_SET_ITEM(dobj, 0, PyString_FromString(""));
-        PyTuple_SET_ITEM(dobj, 1, array_typestr_get(self));
-        res = PyList_New(1);
-        if (res == NULL) {Py_DECREF(dobj); return NULL;}
-        PyList_SET_ITEM(res, 0, dobj);
-        return res;
+    /* get default */
+    dobj = PyTuple_New(2);
+    if (dobj == NULL) return NULL;
+    PyTuple_SET_ITEM(dobj, 0, PyString_FromString(""));
+    PyTuple_SET_ITEM(dobj, 1, array_typestr_get(self));
+    res = PyList_New(1);
+    if (res == NULL) {Py_DECREF(dobj); return NULL;}
+    PyList_SET_ITEM(res, 0, dobj);
+    return res;
 }
 
 static PyObject *
 array_protocol_strides_get(PyArrayObject *self)
 {
-        if PyArray_ISCONTIGUOUS(self) {
-                Py_INCREF(Py_None);
-                return Py_None;
+    if PyArray_ISCONTIGUOUS(self) {
+            Py_INCREF(Py_None);
+            return Py_None;
         }
-        return PyArray_IntTupleFromIntp(self->nd, self->strides);
+    return PyArray_IntTupleFromIntp(self->nd, self->strides);
 }
 
 
@@ -6122,326 +6121,326 @@ array_protocol_strides_get(PyArrayObject *self)
 static PyObject *
 array_dataptr_get(PyArrayObject *self)
 {
-        return Py_BuildValue("NO",
-                             PyLong_FromVoidPtr(self->data),
-                             (self->flags & WRITEABLE ? Py_False :
-                             Py_True));
+    return Py_BuildValue("NO",
+                         PyLong_FromVoidPtr(self->data),
+                         (self->flags & WRITEABLE ? Py_False :
+                          Py_True));
 }
 
 static PyObject *
 array_ctypes_get(PyArrayObject *self)
 {
-        PyObject *_numpy_internal;
-        PyObject *ret;
-        _numpy_internal = PyImport_ImportModule("numpy.core._internal");
-        if (_numpy_internal == NULL) return NULL;
-        ret = PyObject_CallMethod(_numpy_internal, "_ctypes",
-                                  "ON", self,
-                                  PyLong_FromVoidPtr(self->data));
-        Py_DECREF(_numpy_internal);
-        return ret;
+    PyObject *_numpy_internal;
+    PyObject *ret;
+    _numpy_internal = PyImport_ImportModule("numpy.core._internal");
+    if (_numpy_internal == NULL) return NULL;
+    ret = PyObject_CallMethod(_numpy_internal, "_ctypes",
+                              "ON", self,
+                              PyLong_FromVoidPtr(self->data));
+    Py_DECREF(_numpy_internal);
+    return ret;
 }
 
 static PyObject *
 array_interface_get(PyArrayObject *self)
 {
-        PyObject *dict;
-        PyObject *obj;
-        dict = PyDict_New();
-        if (dict == NULL) return NULL;
+    PyObject *dict;
+    PyObject *obj;
+    dict = PyDict_New();
+    if (dict == NULL) return NULL;
 
-        /* dataptr */
-        obj = array_dataptr_get(self);
-        PyDict_SetItemString(dict, "data", obj);
-        Py_DECREF(obj);
+    /* dataptr */
+    obj = array_dataptr_get(self);
+    PyDict_SetItemString(dict, "data", obj);
+    Py_DECREF(obj);
 
-        obj = array_protocol_strides_get(self);
-        PyDict_SetItemString(dict, "strides", obj);
-        Py_DECREF(obj);
+    obj = array_protocol_strides_get(self);
+    PyDict_SetItemString(dict, "strides", obj);
+    Py_DECREF(obj);
 
-        obj = array_protocol_descr_get(self);
-        PyDict_SetItemString(dict, "descr", obj);
-        Py_DECREF(obj);
+    obj = array_protocol_descr_get(self);
+    PyDict_SetItemString(dict, "descr", obj);
+    Py_DECREF(obj);
 
-        obj = arraydescr_protocol_typestr_get(self->descr);
-        PyDict_SetItemString(dict, "typestr", obj);
-        Py_DECREF(obj);
+    obj = arraydescr_protocol_typestr_get(self->descr);
+    PyDict_SetItemString(dict, "typestr", obj);
+    Py_DECREF(obj);
 
-        obj = array_shape_get(self);
-        PyDict_SetItemString(dict, "shape", obj);
-        Py_DECREF(obj);
+    obj = array_shape_get(self);
+    PyDict_SetItemString(dict, "shape", obj);
+    Py_DECREF(obj);
 
-        obj = PyInt_FromLong(3);
-        PyDict_SetItemString(dict, "version", obj);
-        Py_DECREF(obj);
+    obj = PyInt_FromLong(3);
+    PyDict_SetItemString(dict, "version", obj);
+    Py_DECREF(obj);
 
-        return dict;
+    return dict;
 }
 
 static PyObject *
 array_data_get(PyArrayObject *self)
 {
-        intp nbytes;
-        if (!(PyArray_ISONESEGMENT(self))) {
-                PyErr_SetString(PyExc_AttributeError, "cannot get single-"\
-                                "segment buffer for discontiguous array");
-                return NULL;
-        }
-        nbytes = PyArray_NBYTES(self);
-        if PyArray_ISWRITEABLE(self)
-                return PyBuffer_FromReadWriteObject((PyObject *)self, 0,
-                                                    (int) nbytes);
-        else
-                return PyBuffer_FromObject((PyObject *)self, 0, (int) nbytes);
+    intp nbytes;
+    if (!(PyArray_ISONESEGMENT(self))) {
+        PyErr_SetString(PyExc_AttributeError, "cannot get single-"\
+                        "segment buffer for discontiguous array");
+        return NULL;
+    }
+    nbytes = PyArray_NBYTES(self);
+    if PyArray_ISWRITEABLE(self)
+                              return PyBuffer_FromReadWriteObject((PyObject *)self, 0,
+                                                                  (int) nbytes);
+    else
+        return PyBuffer_FromObject((PyObject *)self, 0, (int) nbytes);
 }
 
 static int
 array_data_set(PyArrayObject *self, PyObject *op)
 {
-        void *buf;
-        Py_ssize_t buf_len;
-        int writeable=1;
-
-        if (PyObject_AsWriteBuffer(op, &buf, &buf_len) < 0) {
-                writeable = 0;
-                if (PyObject_AsReadBuffer(op, (const void **)&buf,
-                                          &buf_len) < 0) {
-                        PyErr_SetString(PyExc_AttributeError,
-                                        "object does not have single-segment " \
-                                        "buffer interface");
-                        return -1;
-                }
-        }
-        if (!PyArray_ISONESEGMENT(self)) {
-                PyErr_SetString(PyExc_AttributeError, "cannot set single-" \
-                                "segment buffer for discontiguous array");
-                return -1;
-        }
-        if (PyArray_NBYTES(self) > buf_len) {
-                PyErr_SetString(PyExc_AttributeError,
-                                "not enough data for array");
-                return -1;
-        }
-        if (self->flags & OWNDATA) {
-                PyArray_XDECREF(self);
-                PyDataMem_FREE(self->data);
+    void *buf;
+    Py_ssize_t buf_len;
+    int writeable=1;
+
+    if (PyObject_AsWriteBuffer(op, &buf, &buf_len) < 0) {
+        writeable = 0;
+        if (PyObject_AsReadBuffer(op, (const void **)&buf,
+                                  &buf_len) < 0) {
+            PyErr_SetString(PyExc_AttributeError,
+                            "object does not have single-segment " \
+                            "buffer interface");
+            return -1;
         }
-        if (self->base) {
-                if (self->flags & UPDATEIFCOPY) {
-                        ((PyArrayObject *)self->base)->flags |= WRITEABLE;
-                        self->flags &= ~UPDATEIFCOPY;
-                }
-                Py_DECREF(self->base);
+    }
+    if (!PyArray_ISONESEGMENT(self)) {
+        PyErr_SetString(PyExc_AttributeError, "cannot set single-" \
+                        "segment buffer for discontiguous array");
+        return -1;
+    }
+    if (PyArray_NBYTES(self) > buf_len) {
+        PyErr_SetString(PyExc_AttributeError,
+                        "not enough data for array");
+        return -1;
+    }
+    if (self->flags & OWNDATA) {
+        PyArray_XDECREF(self);
+        PyDataMem_FREE(self->data);
+    }
+    if (self->base) {
+        if (self->flags & UPDATEIFCOPY) {
+            ((PyArrayObject *)self->base)->flags |= WRITEABLE;
+            self->flags &= ~UPDATEIFCOPY;
         }
-        Py_INCREF(op);
-        self->base = op;
-        self->data = buf;
-        self->flags = CARRAY;
-        if (!writeable)
-                self->flags &= ~WRITEABLE;
-        return 0;
+        Py_DECREF(self->base);
+    }
+    Py_INCREF(op);
+    self->base = op;
+    self->data = buf;
+    self->flags = CARRAY;
+    if (!writeable)
+        self->flags &= ~WRITEABLE;
+    return 0;
 }
 
 
 static PyObject *
 array_itemsize_get(PyArrayObject *self)
 {
-        return PyInt_FromLong((long) self->descr->elsize);
+    return PyInt_FromLong((long) self->descr->elsize);
 }
 
 static PyObject *
 array_size_get(PyArrayObject *self)
 {
-        intp size=PyArray_SIZE(self);
+    intp size=PyArray_SIZE(self);
 #if SIZEOF_INTP <= SIZEOF_LONG
-        return PyInt_FromLong((long) size);
+    return PyInt_FromLong((long) size);
 #else
-        if (size > MAX_LONG || size < MIN_LONG)
-                return PyLong_FromLongLong(size);
-        else
-                return PyInt_FromLong((long) size);
+    if (size > MAX_LONG || size < MIN_LONG)
+        return PyLong_FromLongLong(size);
+    else
+        return PyInt_FromLong((long) size);
 #endif
 }
 
 static PyObject *
 array_nbytes_get(PyArrayObject *self)
 {
-        intp nbytes = PyArray_NBYTES(self);
+    intp nbytes = PyArray_NBYTES(self);
 #if SIZEOF_INTP <= SIZEOF_LONG
-        return PyInt_FromLong((long) nbytes);
+    return PyInt_FromLong((long) nbytes);
 #else
-        if (nbytes > MAX_LONG || nbytes < MIN_LONG)
-                return PyLong_FromLongLong(nbytes);
-        else
-                return PyInt_FromLong((long) nbytes);
+    if (nbytes > MAX_LONG || nbytes < MIN_LONG)
+        return PyLong_FromLongLong(nbytes);
+    else
+        return PyInt_FromLong((long) nbytes);
 #endif
 }
 
 
 /* If the type is changed.
-    Also needing change: strides, itemsize
+   Also needing change: strides, itemsize
 
-    Either itemsize is exactly the same
-    or the array is single-segment (contiguous or fortran) with
-    compatibile dimensions
+   Either itemsize is exactly the same
+   or the array is single-segment (contiguous or fortran) with
+   compatibile dimensions
 
-    The shape and strides will be adjusted in that case as well.
+   The shape and strides will be adjusted in that case as well.
 */
 
 static int
 array_descr_set(PyArrayObject *self, PyObject *arg)
 {
-        PyArray_Descr *newtype=NULL;
-        intp newdim;
-        int index;
-        char *msg = "new type not compatible with array.";
+    PyArray_Descr *newtype=NULL;
+    intp newdim;
+    int index;
+    char *msg = "new type not compatible with array.";
 
-        if (!(PyArray_DescrConverter(arg, &newtype)) ||
-            newtype == NULL) {
-                PyErr_SetString(PyExc_TypeError, "invalid data-type for array");
-                return -1;
-        }
-        if (PyDataType_FLAGCHK(newtype, NPY_ITEM_HASOBJECT) ||
-            PyDataType_FLAGCHK(newtype, NPY_ITEM_IS_POINTER) ||
-            PyDataType_FLAGCHK(self->descr, NPY_ITEM_HASOBJECT) || 
-            PyDataType_FLAGCHK(self->descr, NPY_ITEM_IS_POINTER)) {
-                PyErr_SetString(PyExc_TypeError,                      \
-                                "Cannot change data-type for object " \
-                                "array.");
-                Py_DECREF(newtype);
-                return -1;
-        }
+    if (!(PyArray_DescrConverter(arg, &newtype)) ||
+        newtype == NULL) {
+        PyErr_SetString(PyExc_TypeError, "invalid data-type for array");
+        return -1;
+    }
+    if (PyDataType_FLAGCHK(newtype, NPY_ITEM_HASOBJECT) ||
+        PyDataType_FLAGCHK(newtype, NPY_ITEM_IS_POINTER) ||
+        PyDataType_FLAGCHK(self->descr, NPY_ITEM_HASOBJECT) ||
+        PyDataType_FLAGCHK(self->descr, NPY_ITEM_IS_POINTER)) {
+        PyErr_SetString(PyExc_TypeError,                      \
+                        "Cannot change data-type for object " \
+                        "array.");
+        Py_DECREF(newtype);
+        return -1;
+    }
 
-        if (newtype->elsize == 0) {
-                PyErr_SetString(PyExc_TypeError,
-                                "data-type must not be 0-sized");
-                Py_DECREF(newtype);
-                return -1;
-        }
+    if (newtype->elsize == 0) {
+        PyErr_SetString(PyExc_TypeError,
+                        "data-type must not be 0-sized");
+        Py_DECREF(newtype);
+        return -1;
+    }
 
 
-        if ((newtype->elsize != self->descr->elsize) &&         \
-            (self->nd == 0 || !PyArray_ISONESEGMENT(self) || \
-             newtype->subarray)) goto fail;
+    if ((newtype->elsize != self->descr->elsize) &&         \
+        (self->nd == 0 || !PyArray_ISONESEGMENT(self) || \
+         newtype->subarray)) goto fail;
 
-        if (PyArray_ISCONTIGUOUS(self)) index = self->nd - 1;
-        else index = 0;
+    if (PyArray_ISCONTIGUOUS(self)) index = self->nd - 1;
+    else index = 0;
 
-        if (newtype->elsize < self->descr->elsize) {
-                /* if it is compatible increase the size of the
-                   dimension at end (or at the front for FORTRAN)
-                */
-                if (self->descr->elsize % newtype->elsize != 0)
-                        goto fail;
-                newdim = self->descr->elsize / newtype->elsize;
-                self->dimensions[index] *= newdim;
-                self->strides[index] = newtype->elsize;
-        }
-
-        else if (newtype->elsize > self->descr->elsize) {
-
-                /* Determine if last (or first if FORTRAN) dimension
-                   is compatible */
-
-                newdim = self->dimensions[index] * self->descr->elsize;
-                if ((newdim % newtype->elsize) != 0) goto fail;
-
-                self->dimensions[index] = newdim / newtype->elsize;
-                self->strides[index] = newtype->elsize;
-        }
-
-        /* fall through -- adjust type*/
-
-        Py_DECREF(self->descr);
-        if (newtype->subarray) {
-                /* create new array object from data and update
-                   dimensions, strides and descr from it */
-                PyArrayObject *temp;
-
-                /* We would decref newtype here --- temp will
-                   steal a reference to it */
-                temp = (PyArrayObject *)                                \
-                        PyArray_NewFromDescr(&PyArray_Type, newtype, self->nd,
-                                             self->dimensions, self->strides,
-                                             self->data, self->flags, NULL);
-                if (temp == NULL) return -1;
-                PyDimMem_FREE(self->dimensions);
-                self->dimensions = temp->dimensions;
-                self->nd = temp->nd;
-                self->strides = temp->strides;
-                newtype = temp->descr;
-                Py_INCREF(temp->descr);
-                /* Fool deallocator not to delete these*/
-                temp->nd = 0;
-                temp->dimensions = NULL;
-                Py_DECREF(temp);
-        }
+    if (newtype->elsize < self->descr->elsize) {
+        /* if it is compatible increase the size of the
+           dimension at end (or at the front for FORTRAN)
+        */
+        if (self->descr->elsize % newtype->elsize != 0)
+            goto fail;
+        newdim = self->descr->elsize / newtype->elsize;
+        self->dimensions[index] *= newdim;
+        self->strides[index] = newtype->elsize;
+    }
 
-        self->descr = newtype;
-        PyArray_UpdateFlags(self, UPDATE_ALL);
+    else if (newtype->elsize > self->descr->elsize) {
 
-        return 0;
+        /* Determine if last (or first if FORTRAN) dimension
+           is compatible */
+
+        newdim = self->dimensions[index] * self->descr->elsize;
+        if ((newdim % newtype->elsize) != 0) goto fail;
+
+        self->dimensions[index] = newdim / newtype->elsize;
+        self->strides[index] = newtype->elsize;
+    }
+
+    /* fall through -- adjust type*/
+
+    Py_DECREF(self->descr);
+    if (newtype->subarray) {
+        /* create new array object from data and update
+           dimensions, strides and descr from it */
+        PyArrayObject *temp;
+
+        /* We would decref newtype here --- temp will
+           steal a reference to it */
+        temp = (PyArrayObject *)                                \
+            PyArray_NewFromDescr(&PyArray_Type, newtype, self->nd,
+                                 self->dimensions, self->strides,
+                                 self->data, self->flags, NULL);
+        if (temp == NULL) return -1;
+        PyDimMem_FREE(self->dimensions);
+        self->dimensions = temp->dimensions;
+        self->nd = temp->nd;
+        self->strides = temp->strides;
+        newtype = temp->descr;
+        Py_INCREF(temp->descr);
+        /* Fool deallocator not to delete these*/
+        temp->nd = 0;
+        temp->dimensions = NULL;
+        Py_DECREF(temp);
+    }
+
+    self->descr = newtype;
+    PyArray_UpdateFlags(self, UPDATE_ALL);
+
+    return 0;
 
  fail:
-        PyErr_SetString(PyExc_ValueError, msg);
-        Py_DECREF(newtype);
-        return -1;
+    PyErr_SetString(PyExc_ValueError, msg);
+    Py_DECREF(newtype);
+    return -1;
 }
 
 static PyObject *
 array_struct_get(PyArrayObject *self)
 {
-        PyArrayInterface *inter;
-
-        inter = (PyArrayInterface *)_pya_malloc(sizeof(PyArrayInterface));
-        if (inter==NULL) return PyErr_NoMemory();
-        inter->two = 2;
-        inter->nd = self->nd;
-        inter->typekind = self->descr->kind;
-        inter->itemsize = self->descr->elsize;
-        inter->flags = self->flags;
-        /* reset unused flags */
-        inter->flags &= ~(UPDATEIFCOPY | OWNDATA);
-        if (PyArray_ISNOTSWAPPED(self)) inter->flags |= NOTSWAPPED;
-        /* Copy shape and strides over since these can be reset
-           when the array is "reshaped".
-        */
-        if (self->nd > 0) {
-                inter->shape = (intp *)_pya_malloc(2*sizeof(intp)*self->nd);
-                if (inter->shape == NULL) {
-                        _pya_free(inter);
-                        return PyErr_NoMemory();
-                }
-                inter->strides = inter->shape + self->nd;
-                memcpy(inter->shape, self->dimensions, sizeof(intp)*self->nd);
-                memcpy(inter->strides, self->strides, sizeof(intp)*self->nd);
-        }
-        else {
-                inter->shape = NULL;
-                inter->strides = NULL;
-        }
-        inter->data = self->data;
-        if (self->descr->names) {
-                inter->descr = arraydescr_protocol_descr_get(self->descr);
-                if (inter->descr == NULL) PyErr_Clear();
-                else inter->flags &= ARR_HAS_DESCR;
-        }
-        else inter->descr = NULL;
-        Py_INCREF(self);
-        return PyCObject_FromVoidPtrAndDesc(inter, self, gentype_struct_free);
+    PyArrayInterface *inter;
+
+    inter = (PyArrayInterface *)_pya_malloc(sizeof(PyArrayInterface));
+    if (inter==NULL) return PyErr_NoMemory();
+    inter->two = 2;
+    inter->nd = self->nd;
+    inter->typekind = self->descr->kind;
+    inter->itemsize = self->descr->elsize;
+    inter->flags = self->flags;
+    /* reset unused flags */
+    inter->flags &= ~(UPDATEIFCOPY | OWNDATA);
+    if (PyArray_ISNOTSWAPPED(self)) inter->flags |= NOTSWAPPED;
+    /* Copy shape and strides over since these can be reset
+       when the array is "reshaped".
+    */
+    if (self->nd > 0) {
+        inter->shape = (intp *)_pya_malloc(2*sizeof(intp)*self->nd);
+        if (inter->shape == NULL) {
+            _pya_free(inter);
+            return PyErr_NoMemory();
+        }
+        inter->strides = inter->shape + self->nd;
+        memcpy(inter->shape, self->dimensions, sizeof(intp)*self->nd);
+        memcpy(inter->strides, self->strides, sizeof(intp)*self->nd);
+    }
+    else {
+        inter->shape = NULL;
+        inter->strides = NULL;
+    }
+    inter->data = self->data;
+    if (self->descr->names) {
+        inter->descr = arraydescr_protocol_descr_get(self->descr);
+        if (inter->descr == NULL) PyErr_Clear();
+        else inter->flags &= ARR_HAS_DESCR;
+    }
+    else inter->descr = NULL;
+    Py_INCREF(self);
+    return PyCObject_FromVoidPtrAndDesc(inter, self, gentype_struct_free);
 }
 
 static PyObject *
 array_base_get(PyArrayObject *self)
 {
-        if (self->base == NULL) {
-                Py_INCREF(Py_None);
-                return Py_None;
-        }
-        else {
-                Py_INCREF(self->base);
-                return self->base;
-        }
+    if (self->base == NULL) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    else {
+        Py_INCREF(self->base);
+        return self->base;
+    }
 }
 
 /* Create a view of a complex array with an equivalent data-type
@@ -6451,197 +6450,197 @@ array_base_get(PyArrayObject *self)
 static PyArrayObject *
 _get_part(PyArrayObject *self, int imag)
 {
-        PyArray_Descr *type;
-        PyArrayObject *ret;
-        int offset;
+    PyArray_Descr *type;
+    PyArrayObject *ret;
+    int offset;
 
-        type = PyArray_DescrFromType(self->descr->type_num -
-                                     PyArray_NUM_FLOATTYPE);
-        offset = (imag ? type->elsize : 0);
-
-        if (!PyArray_ISNBO(self->descr->byteorder)) {
-                PyArray_Descr *new;
-                new = PyArray_DescrNew(type);
-                new->byteorder = self->descr->byteorder;
-                Py_DECREF(type);
-                type = new;
-        }
-        ret = (PyArrayObject *)                                 \
-                PyArray_NewFromDescr(self->ob_type,
-                                     type,
-                                     self->nd,
-                                     self->dimensions,
-                                     self->strides,
-                                     self->data + offset,
-                                     self->flags, (PyObject *)self);
-        if (ret == NULL) return NULL;
-        ret->flags &= ~CONTIGUOUS;
-        ret->flags &= ~FORTRAN;
-        Py_INCREF(self);
-        ret->base = (PyObject *)self;
-        return ret;
+    type = PyArray_DescrFromType(self->descr->type_num -
+                                 PyArray_NUM_FLOATTYPE);
+    offset = (imag ? type->elsize : 0);
+
+    if (!PyArray_ISNBO(self->descr->byteorder)) {
+        PyArray_Descr *new;
+        new = PyArray_DescrNew(type);
+        new->byteorder = self->descr->byteorder;
+        Py_DECREF(type);
+        type = new;
+    }
+    ret = (PyArrayObject *)                                 \
+        PyArray_NewFromDescr(self->ob_type,
+                             type,
+                             self->nd,
+                             self->dimensions,
+                             self->strides,
+                             self->data + offset,
+                             self->flags, (PyObject *)self);
+    if (ret == NULL) return NULL;
+    ret->flags &= ~CONTIGUOUS;
+    ret->flags &= ~FORTRAN;
+    Py_INCREF(self);
+    ret->base = (PyObject *)self;
+    return ret;
 }
 
 static PyObject *
 array_real_get(PyArrayObject *self)
 {
-        PyArrayObject *ret;
+    PyArrayObject *ret;
 
-        if (PyArray_ISCOMPLEX(self)) {
-                ret = _get_part(self, 0);
-                return (PyObject *)ret;
-        }
-        else {
-                Py_INCREF(self);
-                return (PyObject *)self;
-        }
+    if (PyArray_ISCOMPLEX(self)) {
+        ret = _get_part(self, 0);
+        return (PyObject *)ret;
+    }
+    else {
+        Py_INCREF(self);
+        return (PyObject *)self;
+    }
 }
 
 
 static int
 array_real_set(PyArrayObject *self, PyObject *val)
 {
-        PyArrayObject *ret;
-        PyArrayObject *new;
-        int rint;
+    PyArrayObject *ret;
+    PyArrayObject *new;
+    int rint;
 
-        if (PyArray_ISCOMPLEX(self)) {
-                ret = _get_part(self, 0);
-                if (ret == NULL) return -1;
-        }
-        else {
-                Py_INCREF(self);
-                ret = self;
-        }
-        new = (PyArrayObject *)PyArray_FromAny(val, NULL, 0, 0, 0, NULL);
-        if (new == NULL) {Py_DECREF(ret); return -1;}
-        rint = PyArray_MoveInto(ret, new);
-        Py_DECREF(ret);
-        Py_DECREF(new);
-        return rint;
+    if (PyArray_ISCOMPLEX(self)) {
+        ret = _get_part(self, 0);
+        if (ret == NULL) return -1;
+    }
+    else {
+        Py_INCREF(self);
+        ret = self;
+    }
+    new = (PyArrayObject *)PyArray_FromAny(val, NULL, 0, 0, 0, NULL);
+    if (new == NULL) {Py_DECREF(ret); return -1;}
+    rint = PyArray_MoveInto(ret, new);
+    Py_DECREF(ret);
+    Py_DECREF(new);
+    return rint;
 }
 
 static PyObject *
 array_imag_get(PyArrayObject *self)
 {
-        PyArrayObject *ret;
-        PyArray_Descr *type;
+    PyArrayObject *ret;
+    PyArray_Descr *type;
 
-        if (PyArray_ISCOMPLEX(self)) {
-                ret = _get_part(self, 1);
-                return (PyObject *) ret;
-        }
+    if (PyArray_ISCOMPLEX(self)) {
+        ret = _get_part(self, 1);
+        return (PyObject *) ret;
+    }
+    else {
+        type = self->descr;
+        Py_INCREF(type);
+        ret = (PyArrayObject *)PyArray_Zeros(self->nd,
+                                             self->dimensions,
+                                             type,
+                                             PyArray_ISFORTRAN(self));
+        ret->flags &= ~WRITEABLE;
+        if (PyArray_CheckExact(self))
+            return (PyObject *)ret;
         else {
-                type = self->descr;
-                Py_INCREF(type);
-                ret = (PyArrayObject *)PyArray_Zeros(self->nd,
-                                                     self->dimensions,
-                                                     type,
-                                                     PyArray_ISFORTRAN(self));
-                ret->flags &= ~WRITEABLE;
-                if (PyArray_CheckExact(self))
-                        return (PyObject *)ret;
-                else {
-                        PyObject *newret;
-                        newret = PyArray_View(ret, NULL, self->ob_type);
-                        Py_DECREF(ret);
-                        return newret;
-                }
+            PyObject *newret;
+            newret = PyArray_View(ret, NULL, self->ob_type);
+            Py_DECREF(ret);
+            return newret;
         }
+    }
 }
 
 static int
 array_imag_set(PyArrayObject *self, PyObject *val)
 {
-        if (PyArray_ISCOMPLEX(self)) {
-                PyArrayObject *ret;
-                PyArrayObject *new;
-                int rint;
-
-                ret = _get_part(self, 1);
-                if (ret == NULL) return -1;
-                new = (PyArrayObject *)PyArray_FromAny(val, NULL, 0, 0, 0, NULL);
-                if (new == NULL) {Py_DECREF(ret); return -1;}
-                rint = PyArray_MoveInto(ret, new);
-                Py_DECREF(ret);
-                Py_DECREF(new);
-                return rint;
-        }
-        else {
-                PyErr_SetString(PyExc_TypeError, "array does not have "\
-                                "imaginary part to set");
-                return -1;
-        }
+    if (PyArray_ISCOMPLEX(self)) {
+        PyArrayObject *ret;
+        PyArrayObject *new;
+        int rint;
+
+        ret = _get_part(self, 1);
+        if (ret == NULL) return -1;
+        new = (PyArrayObject *)PyArray_FromAny(val, NULL, 0, 0, 0, NULL);
+        if (new == NULL) {Py_DECREF(ret); return -1;}
+        rint = PyArray_MoveInto(ret, new);
+        Py_DECREF(ret);
+        Py_DECREF(new);
+        return rint;
+    }
+    else {
+        PyErr_SetString(PyExc_TypeError, "array does not have "\
+                        "imaginary part to set");
+        return -1;
+    }
 }
 
 static PyObject *
 array_flat_get(PyArrayObject *self)
 {
-        return PyArray_IterNew((PyObject *)self);
+    return PyArray_IterNew((PyObject *)self);
 }
 
 static int
 array_flat_set(PyArrayObject *self, PyObject *val)
 {
-        PyObject *arr=NULL;
-        int retval = -1;
-        PyArrayIterObject *selfit=NULL, *arrit=NULL;
-        PyArray_Descr *typecode;
-        int swap;
-        PyArray_CopySwapFunc *copyswap;
-
-        typecode = self->descr;
-        Py_INCREF(typecode);
-        arr = PyArray_FromAny(val, typecode,
-                              0, 0, FORCECAST | FORTRAN_IF(self), NULL);
-        if (arr == NULL) return -1;
-        arrit = (PyArrayIterObject *)PyArray_IterNew(arr);
-        if (arrit == NULL) goto exit;
-        selfit = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self);
-        if (selfit == NULL) goto exit;
-
-        if (arrit->size == 0) {retval = 0; goto exit;}
-
-        swap = PyArray_ISNOTSWAPPED(self) != PyArray_ISNOTSWAPPED(arr);
-        copyswap = self->descr->f->copyswap;
-        if (PyDataType_REFCHK(self->descr)) {
-                while(selfit->index < selfit->size) {
-                        PyArray_Item_XDECREF(selfit->dataptr, self->descr);
-                        PyArray_Item_INCREF(arrit->dataptr, PyArray_DESCR(arr));
-                        memmove(selfit->dataptr, arrit->dataptr,
-                                sizeof(PyObject **));
-                        if (swap) 
-                                copyswap(selfit->dataptr, NULL, swap, self);
-                        PyArray_ITER_NEXT(selfit);
-                        PyArray_ITER_NEXT(arrit);
-                        if (arrit->index == arrit->size)
-                                PyArray_ITER_RESET(arrit);
-                }
-                retval = 0;
-                goto exit;
-        }
-
+    PyObject *arr=NULL;
+    int retval = -1;
+    PyArrayIterObject *selfit=NULL, *arrit=NULL;
+    PyArray_Descr *typecode;
+    int swap;
+    PyArray_CopySwapFunc *copyswap;
+
+    typecode = self->descr;
+    Py_INCREF(typecode);
+    arr = PyArray_FromAny(val, typecode,
+                          0, 0, FORCECAST | FORTRAN_IF(self), NULL);
+    if (arr == NULL) return -1;
+    arrit = (PyArrayIterObject *)PyArray_IterNew(arr);
+    if (arrit == NULL) goto exit;
+    selfit = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self);
+    if (selfit == NULL) goto exit;
+
+    if (arrit->size == 0) {retval = 0; goto exit;}
+
+    swap = PyArray_ISNOTSWAPPED(self) != PyArray_ISNOTSWAPPED(arr);
+    copyswap = self->descr->f->copyswap;
+    if (PyDataType_REFCHK(self->descr)) {
         while(selfit->index < selfit->size) {
-                memmove(selfit->dataptr, arrit->dataptr, self->descr->elsize);
-                if (swap)
-                        copyswap(selfit->dataptr, NULL, swap, self);
-                PyArray_ITER_NEXT(selfit);
-                PyArray_ITER_NEXT(arrit);
-                if (arrit->index == arrit->size)
-                        PyArray_ITER_RESET(arrit);
+            PyArray_Item_XDECREF(selfit->dataptr, self->descr);
+            PyArray_Item_INCREF(arrit->dataptr, PyArray_DESCR(arr));
+            memmove(selfit->dataptr, arrit->dataptr,
+                    sizeof(PyObject **));
+            if (swap)
+                copyswap(selfit->dataptr, NULL, swap, self);
+            PyArray_ITER_NEXT(selfit);
+            PyArray_ITER_NEXT(arrit);
+            if (arrit->index == arrit->size)
+                PyArray_ITER_RESET(arrit);
         }
         retval = 0;
+        goto exit;
+    }
+
+    while(selfit->index < selfit->size) {
+        memmove(selfit->dataptr, arrit->dataptr, self->descr->elsize);
+        if (swap)
+            copyswap(selfit->dataptr, NULL, swap, self);
+        PyArray_ITER_NEXT(selfit);
+        PyArray_ITER_NEXT(arrit);
+        if (arrit->index == arrit->size)
+            PyArray_ITER_RESET(arrit);
+    }
+    retval = 0;
  exit:
-        Py_XDECREF(selfit);
-        Py_XDECREF(arrit);
-        Py_XDECREF(arr);
-        return retval;
+    Py_XDECREF(selfit);
+    Py_XDECREF(arrit);
+    Py_XDECREF(arr);
+    return retval;
 }
 
 static PyObject *
 array_transpose_get(PyArrayObject *self)
 {
-        return PyArray_Transpose(self, NULL);
+    return PyArray_Transpose(self, NULL);
 }
 
 /* If this is None, no function call is made
@@ -6650,76 +6649,76 @@ array_transpose_get(PyArrayObject *self)
 static PyObject *
 array_finalize_get(PyArrayObject *self)
 {
-        Py_INCREF(Py_None);
-        return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyGetSetDef array_getsetlist[] = {
-        {"ndim",
-         (getter)array_ndim_get,
-         NULL, NULL},
-        {"flags",
-         (getter)array_flags_get,
-         NULL, NULL},
-        {"shape",
-         (getter)array_shape_get,
-         (setter)array_shape_set,
-         NULL},
-        {"strides",
-         (getter)array_strides_get,
-         (setter)array_strides_set,
-         NULL},
-        {"data",
-         (getter)array_data_get,
-         (setter)array_data_set,
-         NULL},
-        {"itemsize",
-         (getter)array_itemsize_get,
-         NULL, NULL},
-        {"size",
-         (getter)array_size_get,
-         NULL, NULL},
-        {"nbytes",
-         (getter)array_nbytes_get,
-         NULL, NULL},
-        {"base",
-         (getter)array_base_get,
-         NULL, NULL},
-        {"dtype",
-         (getter)array_descr_get,
-         (setter)array_descr_set,
-         NULL},
-        {"real",
-         (getter)array_real_get,
-         (setter)array_real_set,
-         NULL},
-        {"imag",
-         (getter)array_imag_get,
-         (setter)array_imag_set,
-         NULL},
-        {"flat",
-         (getter)array_flat_get,
-         (setter)array_flat_set,
-         NULL},
-        {"ctypes",
-         (getter)array_ctypes_get,
-         NULL, NULL},
-        {"T",
-         (getter)array_transpose_get,
-         NULL, NULL},
-        {"__array_interface__",
-         (getter)array_interface_get,
-         NULL, NULL},
-        {"__array_struct__",
-         (getter)array_struct_get,
-         NULL, NULL},
-        {"__array_priority__",
-         (getter)array_priority_get,
-         NULL, NULL},
-        {"__array_finalize__",
-         (getter)array_finalize_get,
-         NULL, NULL},
-        {NULL, NULL, NULL, NULL},  /* Sentinel */
+    {"ndim",
+     (getter)array_ndim_get,
+     NULL, NULL},
+    {"flags",
+     (getter)array_flags_get,
+     NULL, NULL},
+    {"shape",
+     (getter)array_shape_get,
+     (setter)array_shape_set,
+     NULL},
+    {"strides",
+     (getter)array_strides_get,
+     (setter)array_strides_set,
+     NULL},
+    {"data",
+     (getter)array_data_get,
+     (setter)array_data_set,
+     NULL},
+    {"itemsize",
+     (getter)array_itemsize_get,
+     NULL, NULL},
+    {"size",
+     (getter)array_size_get,
+     NULL, NULL},
+    {"nbytes",
+     (getter)array_nbytes_get,
+     NULL, NULL},
+    {"base",
+     (getter)array_base_get,
+     NULL, NULL},
+    {"dtype",
+     (getter)array_descr_get,
+     (setter)array_descr_set,
+     NULL},
+    {"real",
+     (getter)array_real_get,
+     (setter)array_real_set,
+     NULL},
+    {"imag",
+     (getter)array_imag_get,
+     (setter)array_imag_set,
+     NULL},
+    {"flat",
+     (getter)array_flat_get,
+     (setter)array_flat_set,
+     NULL},
+    {"ctypes",
+     (getter)array_ctypes_get,
+     NULL, NULL},
+    {"T",
+     (getter)array_transpose_get,
+     NULL, NULL},
+    {"__array_interface__",
+     (getter)array_interface_get,
+     NULL, NULL},
+    {"__array_struct__",
+     (getter)array_struct_get,
+     NULL, NULL},
+    {"__array_priority__",
+     (getter)array_priority_get,
+     NULL, NULL},
+    {"__array_finalize__",
+     (getter)array_finalize_get,
+     NULL, NULL},
+    {NULL, NULL, NULL, NULL},  /* Sentinel */
 };
 
 /****************** end of attribute get and set routines *******************/
@@ -6728,73 +6727,73 @@ static PyGetSetDef array_getsetlist[] = {
 static PyObject *
 array_alloc(PyTypeObject *type, Py_ssize_t nitems)
 {
-        PyObject *obj;
-        /* nitems will always be 0 */
-        obj = (PyObject *)_pya_malloc(sizeof(PyArrayObject));
-        PyObject_Init(obj, type);
-        return obj;
+    PyObject *obj;
+    /* nitems will always be 0 */
+    obj = (PyObject *)_pya_malloc(sizeof(PyArrayObject));
+    PyObject_Init(obj, type);
+    return obj;
 }
 
 
 static PyTypeObject PyArray_Type = {
-        PyObject_HEAD_INIT(NULL)
-        0,                                        /*ob_size*/
-        "numpy.ndarray",                          /*tp_name*/
-        sizeof(PyArrayObject),                    /*tp_basicsize*/
-        0,                                        /*tp_itemsize*/
-        /* methods */
-        (destructor)array_dealloc,                /*tp_dealloc  */
-        (printfunc)NULL,                          /*tp_print*/
-        0,                                        /*tp_getattr*/
-        0,                                        /*tp_setattr*/
-        (cmpfunc)0,                       /*tp_compare*/
-        (reprfunc)array_repr,                     /*tp_repr*/
-        &array_as_number,                         /*tp_as_number*/
-        &array_as_sequence,                       /*tp_as_sequence*/
-        &array_as_mapping,                        /*tp_as_mapping*/
-        (hashfunc)0,                              /*tp_hash*/
-        (ternaryfunc)0,                           /*tp_call*/
-        (reprfunc)array_str,              /*tp_str*/
-
-        (getattrofunc)0,                          /*tp_getattro*/
-        (setattrofunc)0,                          /*tp_setattro*/
-        &array_as_buffer,                         /*tp_as_buffer*/
-        (Py_TPFLAGS_DEFAULT
-         | Py_TPFLAGS_BASETYPE
-         | Py_TPFLAGS_CHECKTYPES),                /*tp_flags*/
-        /*Documentation string */
-        0,                                        /*tp_doc*/
-
-        (traverseproc)0,                          /*tp_traverse */
-        (inquiry)0,                               /*tp_clear */
-        (richcmpfunc)array_richcompare,           /*tp_richcompare */
-        offsetof(PyArrayObject, weakreflist),     /*tp_weaklistoffset */
-
-        /* Iterator support (use standard) */
-
-        (getiterfunc)array_iter,                  /* tp_iter */
-        (iternextfunc)0,                          /* tp_iternext */
-
-        /* Sub-classing (new-style object) support */
-
-        array_methods,                            /* tp_methods */
-        0,                                        /* tp_members */
-        array_getsetlist,                         /* tp_getset */
-        0,                                        /* tp_base */
-        0,                                        /* tp_dict */
-        0,                                        /* tp_descr_get */
-        0,                                        /* tp_descr_set */
-        0,                                        /* tp_dictoffset */
-        (initproc)0,                              /* tp_init */
-        array_alloc,                              /* tp_alloc */
-        (newfunc)array_new,                       /* tp_new */
-        0,                                        /* tp_free */
-        0,                                        /* tp_is_gc */
-        0,                                        /* tp_bases */
-        0,                                        /* tp_mro */
-        0,                                        /* tp_cache */
-        0,                                        /* tp_subclasses */
-        0                                         /* tp_weaklist */
+    PyObject_HEAD_INIT(NULL)
+    0,                                        /*ob_size*/
+    "numpy.ndarray",                          /*tp_name*/
+    sizeof(PyArrayObject),                    /*tp_basicsize*/
+    0,                                        /*tp_itemsize*/
+    /* methods */
+    (destructor)array_dealloc,                /*tp_dealloc  */
+    (printfunc)NULL,                          /*tp_print*/
+    0,                                        /*tp_getattr*/
+    0,                                        /*tp_setattr*/
+    (cmpfunc)0,                       /*tp_compare*/
+    (reprfunc)array_repr,                     /*tp_repr*/
+    &array_as_number,                         /*tp_as_number*/
+    &array_as_sequence,                       /*tp_as_sequence*/
+    &array_as_mapping,                        /*tp_as_mapping*/
+    (hashfunc)0,                              /*tp_hash*/
+    (ternaryfunc)0,                           /*tp_call*/
+    (reprfunc)array_str,              /*tp_str*/
+
+    (getattrofunc)0,                          /*tp_getattro*/
+    (setattrofunc)0,                          /*tp_setattro*/
+    &array_as_buffer,                         /*tp_as_buffer*/
+    (Py_TPFLAGS_DEFAULT
+     | Py_TPFLAGS_BASETYPE
+     | Py_TPFLAGS_CHECKTYPES),                /*tp_flags*/
+    /*Documentation string */
+    0,                                        /*tp_doc*/
+
+    (traverseproc)0,                          /*tp_traverse */
+    (inquiry)0,                               /*tp_clear */
+    (richcmpfunc)array_richcompare,           /*tp_richcompare */
+    offsetof(PyArrayObject, weakreflist),     /*tp_weaklistoffset */
+
+    /* Iterator support (use standard) */
+
+    (getiterfunc)array_iter,                  /* tp_iter */
+    (iternextfunc)0,                          /* tp_iternext */
+
+    /* Sub-classing (new-style object) support */
+
+    array_methods,                            /* tp_methods */
+    0,                                        /* tp_members */
+    array_getsetlist,                         /* tp_getset */
+    0,                                        /* tp_base */
+    0,                                        /* tp_dict */
+    0,                                        /* tp_descr_get */
+    0,                                        /* tp_descr_set */
+    0,                                        /* tp_dictoffset */
+    (initproc)0,                              /* tp_init */
+    array_alloc,                              /* tp_alloc */
+    (newfunc)array_new,                       /* tp_new */
+    0,                                        /* tp_free */
+    0,                                        /* tp_is_gc */
+    0,                                        /* tp_bases */
+    0,                                        /* tp_mro */
+    0,                                        /* tp_cache */
+    0,                                        /* tp_subclasses */
+    0                                         /* tp_weaklist */
 };
 
 /* The rest of this code is to build the right kind of array from a python */
@@ -6803,78 +6802,78 @@ static PyTypeObject PyArray_Type = {
 static int
 discover_depth(PyObject *s, int max, int stop_at_string, int stop_at_tuple)
 {
-        int d=0;
-        PyObject *e;
-
-        if(max < 1) return -1;
-
-        if(! PySequence_Check(s) || PyInstance_Check(s) || \
-           PySequence_Length(s) < 0) {
-                PyErr_Clear(); return 0;
-        }
-        if (PyArray_Check(s))
-                return PyArray_NDIM(s);
-        if (PyArray_IsScalar(s, Generic)) return 0;
-        if (PyString_Check(s) || PyBuffer_Check(s) || PyUnicode_Check(s))
-                return stop_at_string ? 0:1;
-        if (stop_at_tuple && PyTuple_Check(s)) return 0;
-        if ((e=PyObject_GetAttrString(s, "__array_struct__")) != NULL) {
-                d = -1;
-                if (PyCObject_Check(e)) {
-                        PyArrayInterface *inter;
-                        inter = (PyArrayInterface *)PyCObject_AsVoidPtr(e);
-                        if (inter->two == 2) {
-                                d = inter->nd;
-                        }
-                }
-                Py_DECREF(e);
-                if (d > -1) return d;
-        }
-        else PyErr_Clear();
-        if ((e=PyObject_GetAttrString(s, "__array_interface__")) != NULL) {
-                d = -1;
-                if (PyDict_Check(e)) {
-                        PyObject *new;
-                        new = PyDict_GetItemString(e, "shape");
-                        if (new && PyTuple_Check(new))
-                                d = PyTuple_GET_SIZE(new);
-                }
-                Py_DECREF(e);
-                if (d>-1) return d;
-        }
-        else PyErr_Clear();
+    int d=0;
+    PyObject *e;
+
+    if(max < 1) return -1;
 
-        if (PySequence_Length(s) == 0)
-                return 1;
-        if ((e=PySequence_GetItem(s,0)) == NULL) return -1;
-        if(e!=s) {
-                d=discover_depth(e, max-1, stop_at_string, stop_at_tuple);
-                if(d >= 0) d++;
+    if(! PySequence_Check(s) || PyInstance_Check(s) || \
+       PySequence_Length(s) < 0) {
+        PyErr_Clear(); return 0;
+    }
+    if (PyArray_Check(s))
+        return PyArray_NDIM(s);
+    if (PyArray_IsScalar(s, Generic)) return 0;
+    if (PyString_Check(s) || PyBuffer_Check(s) || PyUnicode_Check(s))
+        return stop_at_string ? 0:1;
+    if (stop_at_tuple && PyTuple_Check(s)) return 0;
+    if ((e=PyObject_GetAttrString(s, "__array_struct__")) != NULL) {
+        d = -1;
+        if (PyCObject_Check(e)) {
+            PyArrayInterface *inter;
+            inter = (PyArrayInterface *)PyCObject_AsVoidPtr(e);
+            if (inter->two == 2) {
+                d = inter->nd;
+            }
+        }
+        Py_DECREF(e);
+        if (d > -1) return d;
+    }
+    else PyErr_Clear();
+    if ((e=PyObject_GetAttrString(s, "__array_interface__")) != NULL) {
+        d = -1;
+        if (PyDict_Check(e)) {
+            PyObject *new;
+            new = PyDict_GetItemString(e, "shape");
+            if (new && PyTuple_Check(new))
+                d = PyTuple_GET_SIZE(new);
         }
         Py_DECREF(e);
-        return d;
+        if (d>-1) return d;
+    }
+    else PyErr_Clear();
+
+    if (PySequence_Length(s) == 0)
+        return 1;
+    if ((e=PySequence_GetItem(s,0)) == NULL) return -1;
+    if(e!=s) {
+        d=discover_depth(e, max-1, stop_at_string, stop_at_tuple);
+        if(d >= 0) d++;
+    }
+    Py_DECREF(e);
+    return d;
 }
 
 static int
 discover_itemsize(PyObject *s, int nd, int *itemsize)
 {
-        int n, r, i;
-        PyObject *e;
+    int n, r, i;
+    PyObject *e;
 
-        n = PyObject_Length(s);
+    n = PyObject_Length(s);
 
-        if ((nd == 0) || PyString_Check(s) ||           \
-            PyUnicode_Check(s) || PyBuffer_Check(s)) {
-                *itemsize = MAX(*itemsize, n);
-                return 0;
-        }
-        for (i=0; i<n; i++) {
-                if ((e=PySequence_GetItem(s,i))==NULL) return -1;
-                r=discover_itemsize(e,nd-1,itemsize);
-                Py_DECREF(e);
-                if (r == -1) return -1;
-        }
+    if ((nd == 0) || PyString_Check(s) ||           \
+        PyUnicode_Check(s) || PyBuffer_Check(s)) {
+        *itemsize = MAX(*itemsize, n);
         return 0;
+    }
+    for (i=0; i<n; i++) {
+        if ((e=PySequence_GetItem(s,i))==NULL) return -1;
+        r=discover_itemsize(e,nd-1,itemsize);
+        Py_DECREF(e);
+        if (r == -1) return -1;
+    }
+    return 0;
 }
 
 /* Take an arbitrary object known to represent
@@ -6884,30 +6883,30 @@ discover_itemsize(PyObject *s, int nd, int *itemsize)
 static int
 discover_dimensions(PyObject *s, int nd, intp *d, int check_it)
 {
-        PyObject *e;
-        int r, n, i, n_lower;
-
-        n=PyObject_Length(s);
-        *d = n;
-        if(*d < 0) return -1;
-        if(nd <= 1) return 0;
-        n_lower = 0;
-        for(i=0; i<n; i++) {
-                if ((e=PySequence_GetItem(s,i)) == NULL) return -1;
-                r=discover_dimensions(e,nd-1,d+1,check_it);
-                Py_DECREF(e);
-
-                if (r == -1) return -1;
-                if (check_it && n_lower != 0 && n_lower != d[1]) {
-                        PyErr_SetString(PyExc_ValueError,
-                                        "inconsistent shape in sequence");
-                        return -1;
-                }
-                if (d[1] > n_lower) n_lower = d[1];
+    PyObject *e;
+    int r, n, i, n_lower;
+
+    n=PyObject_Length(s);
+    *d = n;
+    if(*d < 0) return -1;
+    if(nd <= 1) return 0;
+    n_lower = 0;
+    for(i=0; i<n; i++) {
+        if ((e=PySequence_GetItem(s,i)) == NULL) return -1;
+        r=discover_dimensions(e,nd-1,d+1,check_it);
+        Py_DECREF(e);
+
+        if (r == -1) return -1;
+        if (check_it && n_lower != 0 && n_lower != d[1]) {
+            PyErr_SetString(PyExc_ValueError,
+                            "inconsistent shape in sequence");
+            return -1;
         }
-        d[1] = n_lower;
+        if (d[1] > n_lower) n_lower = d[1];
+    }
+    d[1] = n_lower;
 
-        return 0;
+    return 0;
 }
 
 /* new reference */
@@ -6916,62 +6915,62 @@ discover_dimensions(PyObject *s, int nd, intp *d, int check_it)
 static PyArray_Descr *
 _array_small_type(PyArray_Descr *chktype, PyArray_Descr* mintype)
 {
-        PyArray_Descr *outtype;
-        int outtype_num, save_num;
+    PyArray_Descr *outtype;
+    int outtype_num, save_num;
 
-        if (PyArray_EquivTypes(chktype, mintype)) {
-                Py_INCREF(mintype);
-                return mintype;
-        }
+    if (PyArray_EquivTypes(chktype, mintype)) {
+        Py_INCREF(mintype);
+        return mintype;
+    }
 
 
-        if (chktype->type_num > mintype->type_num)
-                outtype_num = chktype->type_num;
+    if (chktype->type_num > mintype->type_num)
+        outtype_num = chktype->type_num;
+    else {
+        if (PyDataType_ISOBJECT(chktype) && \
+            PyDataType_ISSTRING(mintype)) {
+            return PyArray_DescrFromType(NPY_OBJECT);
+        }
         else {
-                if (PyDataType_ISOBJECT(chktype) && \
-                    PyDataType_ISSTRING(mintype)) {
-                        return PyArray_DescrFromType(NPY_OBJECT);
-                }
-                else {
-                        outtype_num = mintype->type_num;
-                }
+            outtype_num = mintype->type_num;
         }
+    }
 
-        save_num = outtype_num;
-        while(outtype_num < PyArray_NTYPES &&
-              !(PyArray_CanCastSafely(chktype->type_num, outtype_num)
-                && PyArray_CanCastSafely(mintype->type_num, outtype_num)))
-                outtype_num++;
-        if (outtype_num == PyArray_NTYPES) {
-                outtype = PyArray_DescrFromType(save_num);
+    save_num = outtype_num;
+    while(outtype_num < PyArray_NTYPES &&
+          !(PyArray_CanCastSafely(chktype->type_num, outtype_num)
+            && PyArray_CanCastSafely(mintype->type_num, outtype_num)))
+        outtype_num++;
+    if (outtype_num == PyArray_NTYPES) {
+        outtype = PyArray_DescrFromType(save_num);
+    }
+    else {
+        outtype = PyArray_DescrFromType(outtype_num);
+    }
+    if (PyTypeNum_ISEXTENDED(outtype->type_num)) {
+        int testsize = outtype->elsize;
+        register int chksize, minsize;
+        chksize = chktype->elsize;
+        minsize = mintype->elsize;
+        /* Handle string->unicode case separately
+           because string itemsize is 4* as large */
+        if (outtype->type_num == PyArray_UNICODE &&
+            mintype->type_num == PyArray_STRING) {
+            testsize = MAX(chksize, 4*minsize);
         }
         else {
-                outtype = PyArray_DescrFromType(outtype_num);
-        }
-        if (PyTypeNum_ISEXTENDED(outtype->type_num)) {
-                int testsize = outtype->elsize;
-                register int chksize, minsize;
-                chksize = chktype->elsize;
-                minsize = mintype->elsize;
-                /* Handle string->unicode case separately
-                   because string itemsize is 4* as large */
-                if (outtype->type_num == PyArray_UNICODE &&
-                    mintype->type_num == PyArray_STRING) {
-                        testsize = MAX(chksize, 4*minsize);
-                }
-                else {
-                        testsize = MAX(chksize, minsize);
-                }
-                if (testsize != outtype->elsize) {
-                        PyArray_DESCR_REPLACE(outtype);
-                        outtype->elsize = testsize;
-                        Py_XDECREF(outtype->fields);
-                        outtype->fields = NULL;
-                        Py_XDECREF(outtype->names);
-                        outtype->names = NULL;
-                }
+            testsize = MAX(chksize, minsize);
+        }
+        if (testsize != outtype->elsize) {
+            PyArray_DESCR_REPLACE(outtype);
+            outtype->elsize = testsize;
+            Py_XDECREF(outtype->fields);
+            outtype->fields = NULL;
+            Py_XDECREF(outtype->names);
+            outtype->names = NULL;
         }
-        return outtype;
+    }
+    return outtype;
 }
 
 static PyArray_Descr *
@@ -6979,26 +6978,26 @@ _array_find_python_scalar_type(PyObject *op)
 {
     if (PyFloat_Check(op)) {
         return PyArray_DescrFromType(PyArray_DOUBLE);
-    } 
+    }
     else if (PyComplex_Check(op)) {
-            return PyArray_DescrFromType(PyArray_CDOUBLE);
-    } 
+        return PyArray_DescrFromType(PyArray_CDOUBLE);
+    }
     else if (PyInt_Check(op)) {
-            /* bools are a subclass of int */
-            if (PyBool_Check(op)) {
-                    return PyArray_DescrFromType(PyArray_BOOL);
-            } else {
-                    return  PyArray_DescrFromType(PyArray_LONG);
-            }
-    } 
+        /* bools are a subclass of int */
+        if (PyBool_Check(op)) {
+            return PyArray_DescrFromType(PyArray_BOOL);
+        } else {
+            return  PyArray_DescrFromType(PyArray_LONG);
+        }
+    }
     else if (PyLong_Check(op)) {
-            /* if integer can fit into a longlong then return that
-             */
-            if ((PyLong_AsLongLong(op) == -1) && PyErr_Occurred()) {
-                    PyErr_Clear();
-                    return PyArray_DescrFromType(PyArray_OBJECT);
-            }
-            return PyArray_DescrFromType(PyArray_LONGLONG);
+        /* if integer can fit into a longlong then return that
+         */
+        if ((PyLong_AsLongLong(op) == -1) && PyErr_Occurred()) {
+            PyErr_Clear();
+            return PyArray_DescrFromType(PyArray_OBJECT);
+        }
+        return PyArray_DescrFromType(PyArray_LONGLONG);
     }
     return NULL;
 }
@@ -7006,23 +7005,23 @@ _array_find_python_scalar_type(PyObject *op)
 static PyArray_Descr *
 _use_default_type(PyObject *op)
 {
-        int typenum, l;
-        PyObject *type;
-        
-        typenum = -1;
-        l = 0;
-        type = (PyObject *)op->ob_type;
-        while (l < PyArray_NUMUSERTYPES) {
-                if (type == (PyObject *)(userdescrs[l]->typeobj)) {
-                        typenum = l + PyArray_USERDEF;
-                        break;
-                }
-                l++;
-        }
-        if (typenum == -1) {
-                typenum = PyArray_OBJECT;
+    int typenum, l;
+    PyObject *type;
+
+    typenum = -1;
+    l = 0;
+    type = (PyObject *)op->ob_type;
+    while (l < PyArray_NUMUSERTYPES) {
+        if (type == (PyObject *)(userdescrs[l]->typeobj)) {
+            typenum = l + PyArray_USERDEF;
+            break;
         }
-        return PyArray_DescrFromType(typenum);
+        l++;
+    }
+    if (typenum == -1) {
+        typenum = PyArray_OBJECT;
+    }
+    return PyArray_DescrFromType(typenum);
 }
 
 
@@ -7038,208 +7037,208 @@ _use_default_type(PyObject *op)
 static PyArray_Descr *
 _array_find_type(PyObject *op, PyArray_Descr *minitype, int max)
 {
-        int l;
-        PyObject *ip;
-        PyArray_Descr *chktype=NULL;
-        PyArray_Descr *outtype;
-
-        /* These need to come first because if op already carries
-           a descr structure, then we want it to be the result if minitype
-           is NULL.
-        */
+    int l;
+    PyObject *ip;
+    PyArray_Descr *chktype=NULL;
+    PyArray_Descr *outtype;
+
+    /* These need to come first because if op already carries
+       a descr structure, then we want it to be the result if minitype
+       is NULL.
+    */
+
+    if (PyArray_Check(op)) {
+        chktype = PyArray_DESCR(op);
+        Py_INCREF(chktype);
+        if (minitype == NULL) return chktype;
+        Py_INCREF(minitype);
+        goto finish;
+    }
 
-        if (PyArray_Check(op)) {
-                chktype = PyArray_DESCR(op);
-                Py_INCREF(chktype);
-                if (minitype == NULL) return chktype;
-                Py_INCREF(minitype);
-                goto finish;
-        }
+    if (PyArray_IsScalar(op, Generic)) {
+        chktype = PyArray_DescrFromScalar(op);
+        if (minitype == NULL) return chktype;
+        Py_INCREF(minitype);
+        goto finish;
+    }
 
-        if (PyArray_IsScalar(op, Generic)) {
-                chktype = PyArray_DescrFromScalar(op);
-                if (minitype == NULL) return chktype;
-                Py_INCREF(minitype);
-                goto finish;
-        }
+    if (minitype == NULL) {
+        minitype = PyArray_DescrFromType(PyArray_BOOL);
+    }
+    else Py_INCREF(minitype);
 
-        if (minitype == NULL) {
-                minitype = PyArray_DescrFromType(PyArray_BOOL);
-        }
-        else Py_INCREF(minitype);
+    if (max < 0) goto deflt;
 
-        if (max < 0) goto deflt;
+    chktype = _array_find_python_scalar_type(op);
+    if (chktype) {
+        goto finish;
+    }
 
-        chktype = _array_find_python_scalar_type(op);
-        if (chktype) {
-            goto finish;
+    if ((ip=PyObject_GetAttrString(op, "__array_interface__"))!=NULL) {
+        if (PyDict_Check(ip)) {
+            PyObject *new;
+            new = PyDict_GetItemString(ip, "typestr");
+            if (new && PyString_Check(new)) {
+                chktype =_array_typedescr_fromstr       \
+                    (PyString_AS_STRING(new));
+            }
         }
+        Py_DECREF(ip);
+        if (chktype) goto finish;
+    }
+    else PyErr_Clear();
 
-        if ((ip=PyObject_GetAttrString(op, "__array_interface__"))!=NULL) {
-                if (PyDict_Check(ip)) {
-                        PyObject *new;
-                        new = PyDict_GetItemString(ip, "typestr");
-                        if (new && PyString_Check(new)) {
-                                chktype =_array_typedescr_fromstr       \
-                                        (PyString_AS_STRING(new));
-                        }
-                }
-                Py_DECREF(ip);
-                if (chktype) goto finish;
-        }
-        else PyErr_Clear();
-
-        if ((ip=PyObject_GetAttrString(op, "__array_struct__")) != NULL) {
-                PyArrayInterface *inter;
-                char buf[40];
-                if (PyCObject_Check(ip)) {
-                        inter=(PyArrayInterface *)PyCObject_AsVoidPtr(ip);
-                        if (inter->two == 2) {
-                                snprintf(buf, 40, "|%c%d", inter->typekind,
-                                         inter->itemsize);
-                                chktype = _array_typedescr_fromstr(buf);
-                        }
-                }
-                Py_DECREF(ip);
-                if (chktype) goto finish;
+    if ((ip=PyObject_GetAttrString(op, "__array_struct__")) != NULL) {
+        PyArrayInterface *inter;
+        char buf[40];
+        if (PyCObject_Check(ip)) {
+            inter=(PyArrayInterface *)PyCObject_AsVoidPtr(ip);
+            if (inter->two == 2) {
+                snprintf(buf, 40, "|%c%d", inter->typekind,
+                         inter->itemsize);
+                chktype = _array_typedescr_fromstr(buf);
+            }
         }
-        else PyErr_Clear();
+        Py_DECREF(ip);
+        if (chktype) goto finish;
+    }
+    else PyErr_Clear();
 
-        if (PyString_Check(op)) {
-                chktype = PyArray_DescrNewFromType(PyArray_STRING);
-                chktype->elsize = PyString_GET_SIZE(op);
-                goto finish;
-        }
+    if (PyString_Check(op)) {
+        chktype = PyArray_DescrNewFromType(PyArray_STRING);
+        chktype->elsize = PyString_GET_SIZE(op);
+        goto finish;
+    }
 
-        if (PyUnicode_Check(op)) {
-                chktype = PyArray_DescrNewFromType(PyArray_UNICODE);
-                chktype->elsize = PyUnicode_GET_DATA_SIZE(op);
+    if (PyUnicode_Check(op)) {
+        chktype = PyArray_DescrNewFromType(PyArray_UNICODE);
+        chktype->elsize = PyUnicode_GET_DATA_SIZE(op);
 #ifndef Py_UNICODE_WIDE
-                chktype->elsize <<= 1;
+        chktype->elsize <<= 1;
 #endif
-                goto finish;
-        }
+        goto finish;
+    }
 
-        if (PyBuffer_Check(op)) {
-                chktype = PyArray_DescrNewFromType(PyArray_VOID);
-                chktype->elsize = op->ob_type->tp_as_sequence->sq_length(op);
-                PyErr_Clear();
-                goto finish;
-        }
+    if (PyBuffer_Check(op)) {
+        chktype = PyArray_DescrNewFromType(PyArray_VOID);
+        chktype->elsize = op->ob_type->tp_as_sequence->sq_length(op);
+        PyErr_Clear();
+        goto finish;
+    }
 
-        if (PyObject_HasAttrString(op, "__array__")) {
-                ip = PyObject_CallMethod(op, "__array__", NULL);
-                if(ip && PyArray_Check(ip)) {
-                        chktype = PyArray_DESCR(ip);
-                        Py_INCREF(chktype);
-                        Py_DECREF(ip);
-                        goto finish;
-                }
-                Py_XDECREF(ip);
-                if (PyErr_Occurred()) PyErr_Clear();
+    if (PyObject_HasAttrString(op, "__array__")) {
+        ip = PyObject_CallMethod(op, "__array__", NULL);
+        if(ip && PyArray_Check(ip)) {
+            chktype = PyArray_DESCR(ip);
+            Py_INCREF(chktype);
+            Py_DECREF(ip);
+            goto finish;
         }
+        Py_XDECREF(ip);
+        if (PyErr_Occurred()) PyErr_Clear();
+    }
 
-        if (PyInstance_Check(op)) goto deflt;
+    if (PyInstance_Check(op)) goto deflt;
 
-        if (PySequence_Check(op)) {
+    if (PySequence_Check(op)) {
 
-                l = PyObject_Length(op);
-                if (l < 0 && PyErr_Occurred()) {
-                        PyErr_Clear();
-                        goto deflt;
-                }
-                if (l == 0 && minitype->type_num == PyArray_BOOL) {
-                        Py_DECREF(minitype);
-                        minitype = PyArray_DescrFromType(PyArray_DEFAULT);
-                }
-                while (--l >= 0) {
-                        PyArray_Descr *newtype;
-                        ip = PySequence_GetItem(op, l);
-                        if (ip==NULL) {
-                                PyErr_Clear();
-                                goto deflt;
-                        }
-                        chktype = _array_find_type(ip, minitype, max-1);
-                        newtype = _array_small_type(chktype, minitype);
-                        Py_DECREF(minitype);
-                        minitype = newtype;
-                        Py_DECREF(chktype);
-                        Py_DECREF(ip);
-                }
-                chktype = minitype;
-                Py_INCREF(minitype);
-                goto finish;
+        l = PyObject_Length(op);
+        if (l < 0 && PyErr_Occurred()) {
+            PyErr_Clear();
+            goto deflt;
+        }
+        if (l == 0 && minitype->type_num == PyArray_BOOL) {
+            Py_DECREF(minitype);
+            minitype = PyArray_DescrFromType(PyArray_DEFAULT);
         }
+        while (--l >= 0) {
+            PyArray_Descr *newtype;
+            ip = PySequence_GetItem(op, l);
+            if (ip==NULL) {
+                PyErr_Clear();
+                goto deflt;
+            }
+            chktype = _array_find_type(ip, minitype, max-1);
+            newtype = _array_small_type(chktype, minitype);
+            Py_DECREF(minitype);
+            minitype = newtype;
+            Py_DECREF(chktype);
+            Py_DECREF(ip);
+        }
+        chktype = minitype;
+        Py_INCREF(minitype);
+        goto finish;
+    }
 
 
  deflt:
-        chktype = _use_default_type(op);
+    chktype = _use_default_type(op);
 
  finish:
 
-        outtype = _array_small_type(chktype, minitype);
-        Py_DECREF(chktype);
-        Py_DECREF(minitype);
-        /* VOID Arrays should not occur by "default" 
-           unless input was already a VOID */
-        if (outtype->type_num == PyArray_VOID && \
-            minitype->type_num != PyArray_VOID) {
-                Py_DECREF(outtype);
-                return PyArray_DescrFromType(PyArray_OBJECT);
-        }
-        return outtype;
+    outtype = _array_small_type(chktype, minitype);
+    Py_DECREF(chktype);
+    Py_DECREF(minitype);
+    /* VOID Arrays should not occur by "default"
+       unless input was already a VOID */
+    if (outtype->type_num == PyArray_VOID && \
+        minitype->type_num != PyArray_VOID) {
+        Py_DECREF(outtype);
+        return PyArray_DescrFromType(PyArray_OBJECT);
+    }
+    return outtype;
 }
 
 /* adapted from Numarray */
-static int 
+static int
 setArrayFromSequence(PyArrayObject *a, PyObject *s, int dim, intp offset)
 {
-        Py_ssize_t i, slen = PySequence_Length(s);
-        int res = 0;
+    Py_ssize_t i, slen = PySequence_Length(s);
+    int res = 0;
 
-        if (dim > a->nd) {
-                PyErr_Format(PyExc_ValueError,
-                             "setArrayFromSequence: sequence/array dimensions mismatch.");
-                return -1;
-        }
+    if (dim > a->nd) {
+        PyErr_Format(PyExc_ValueError,
+                     "setArrayFromSequence: sequence/array dimensions mismatch.");
+        return -1;
+    }
 
-        if (slen != a->dimensions[dim]) {
-                PyErr_Format(PyExc_ValueError,
-                             "setArrayFromSequence: sequence/array shape mismatch.");
-                return -1;
-        }
+    if (slen != a->dimensions[dim]) {
+        PyErr_Format(PyExc_ValueError,
+                     "setArrayFromSequence: sequence/array shape mismatch.");
+        return -1;
+    }
 
-        for(i=0; i<slen; i++) {
-                PyObject *o = PySequence_GetItem(s, i);
-                if ((a->nd - dim) > 1) {
-                        res = setArrayFromSequence(a, o, dim+1, offset);
-                }
-                else {
-                        res = a->descr->f->setitem(o, (a->data + offset), a);
-                }
-                Py_DECREF(o);
-                if (res < 0) return res;
-                offset += a->strides[dim];
+    for(i=0; i<slen; i++) {
+        PyObject *o = PySequence_GetItem(s, i);
+        if ((a->nd - dim) > 1) {
+            res = setArrayFromSequence(a, o, dim+1, offset);
         }
-        return 0;
+        else {
+            res = a->descr->f->setitem(o, (a->data + offset), a);
+        }
+        Py_DECREF(o);
+        if (res < 0) return res;
+        offset += a->strides[dim];
+    }
+    return 0;
 }
 
 
 static int
 Assign_Array(PyArrayObject *self, PyObject *v)
 {
-        if (!PySequence_Check(v)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "assignment from non-sequence");
-                return -1;
-        }
-        if (self->nd == 0) {
-                PyErr_SetString(PyExc_ValueError,
-                                "assignment to 0-d array");
-                return -1;
-        }
+    if (!PySequence_Check(v)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "assignment from non-sequence");
+        return -1;
+    }
+    if (self->nd == 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "assignment to 0-d array");
+        return -1;
+    }
 
-        return setArrayFromSequence(self, v, 0, 0);
+    return setArrayFromSequence(self, v, 0, 0);
 }
 
 /* "Array Scalars don't call this code" */
@@ -7247,42 +7246,42 @@ Assign_Array(PyArrayObject *self, PyObject *v)
 static PyObject *
 Array_FromPyScalar(PyObject *op, PyArray_Descr *typecode)
 {
-        PyArrayObject *ret;
-        int itemsize;
-        int type;
+    PyArrayObject *ret;
+    int itemsize;
+    int type;
 
-        itemsize = typecode->elsize;
-        type = typecode->type_num;
+    itemsize = typecode->elsize;
+    type = typecode->type_num;
 
-        if (itemsize == 0 && PyTypeNum_ISEXTENDED(type)) {
-                itemsize = PyObject_Length(op);
-                if (type == PyArray_UNICODE) itemsize *= 4;
+    if (itemsize == 0 && PyTypeNum_ISEXTENDED(type)) {
+        itemsize = PyObject_Length(op);
+        if (type == PyArray_UNICODE) itemsize *= 4;
 
-                if (itemsize != typecode->elsize) {
-                        PyArray_DESCR_REPLACE(typecode);
-                        typecode->elsize = itemsize;
-                }
+        if (itemsize != typecode->elsize) {
+            PyArray_DESCR_REPLACE(typecode);
+            typecode->elsize = itemsize;
         }
+    }
 
-        ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, typecode,
-                                                    0, NULL,
-                                                    NULL, NULL, 0, NULL);
-        if (ret == NULL) return NULL;
-        if (ret->nd > 0) {
-                PyErr_SetString(PyExc_ValueError,
-                                "shape-mismatch on array construction");
-                Py_DECREF(ret);
-                return NULL;
-        }
+    ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, typecode,
+                                                0, NULL,
+                                                NULL, NULL, 0, NULL);
+    if (ret == NULL) return NULL;
+    if (ret->nd > 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "shape-mismatch on array construction");
+        Py_DECREF(ret);
+        return NULL;
+    }
 
-        ret->descr->f->setitem(op, ret->data, ret);
+    ret->descr->f->setitem(op, ret->data, ret);
 
-        if (PyErr_Occurred()) {
-                Py_DECREF(ret);
-                return NULL;
-        } else {
-                return (PyObject *)ret;
-        }
+    if (PyErr_Occurred()) {
+        Py_DECREF(ret);
+        return NULL;
+    } else {
+        return (PyObject *)ret;
+    }
 }
 
 
@@ -7297,253 +7296,253 @@ Array_FromPyScalar(PyObject *op, PyArray_Descr *typecode)
 static int
 object_depth_and_dimension(PyObject *s, int max, intp *dims)
 {
-        intp *newdims, *test_dims;
-        int nd, test_nd;
-        int i, islist;
-        intp size;
-        PyObject *obj;
+    intp *newdims, *test_dims;
+    int nd, test_nd;
+    int i, islist;
+    intp size;
+    PyObject *obj;
 
-        islist = PyList_Check(s);
-        if (!(islist || PyTuple_Check(s)) ||
-            ((size = PySequence_Size(s)) == 0))
-                return 0;
-        if (max < 2) {
-                if (max < 1) return 0;
-                dims[0] = size;
-                return 1;
-        }
-        newdims = PyDimMem_NEW(2*(max-1));
-        test_dims = newdims + (max-1);
-        if (islist) obj = PyList_GET_ITEM(s, 0);
-        else obj = PyTuple_GET_ITEM(s, 0);
-        nd = object_depth_and_dimension(obj, max-1, newdims);
-        for (i=1; i<size; i++) {
-                if (islist) obj = PyList_GET_ITEM(s, i);
-                else obj = PyTuple_GET_ITEM(s, i);
-                test_nd = object_depth_and_dimension(obj, max-1, test_dims);
-                if ((nd != test_nd) ||
-                    (!PyArray_CompareLists(newdims, test_dims, nd))) {
-                        nd = 0;
-                        break;
-                }
+    islist = PyList_Check(s);
+    if (!(islist || PyTuple_Check(s)) ||
+        ((size = PySequence_Size(s)) == 0))
+        return 0;
+    if (max < 2) {
+        if (max < 1) return 0;
+        dims[0] = size;
+        return 1;
+    }
+    newdims = PyDimMem_NEW(2*(max-1));
+    test_dims = newdims + (max-1);
+    if (islist) obj = PyList_GET_ITEM(s, 0);
+    else obj = PyTuple_GET_ITEM(s, 0);
+    nd = object_depth_and_dimension(obj, max-1, newdims);
+    for (i=1; i<size; i++) {
+        if (islist) obj = PyList_GET_ITEM(s, i);
+        else obj = PyTuple_GET_ITEM(s, i);
+        test_nd = object_depth_and_dimension(obj, max-1, test_dims);
+        if ((nd != test_nd) ||
+            (!PyArray_CompareLists(newdims, test_dims, nd))) {
+            nd = 0;
+            break;
         }
+    }
 
-        for (i=1; i<=nd; i++) dims[i] = newdims[i-1];
-        dims[0] = size;
-        PyDimMem_FREE(newdims);
-        return nd+1;
+    for (i=1; i<=nd; i++) dims[i] = newdims[i-1];
+    dims[0] = size;
+    PyDimMem_FREE(newdims);
+    return nd+1;
 }
 
 static PyObject *
 ObjectArray_FromNestedList(PyObject *s, PyArray_Descr *typecode, int fortran)
 {
-        int nd;
-        intp d[MAX_DIMS];
-        PyArrayObject *r;
+    int nd;
+    intp d[MAX_DIMS];
+    PyArrayObject *r;
 
-        /* Get the depth and the number of dimensions */
-        nd = object_depth_and_dimension(s, MAX_DIMS, d);
-        if (nd < 0) return NULL;
+    /* Get the depth and the number of dimensions */
+    nd = object_depth_and_dimension(s, MAX_DIMS, d);
+    if (nd < 0) return NULL;
 
-        if (nd == 0) return Array_FromPyScalar(s, typecode);
+    if (nd == 0) return Array_FromPyScalar(s, typecode);
 
-        r=(PyArrayObject*)PyArray_NewFromDescr(&PyArray_Type, typecode,
-                                               nd, d,
-                                               NULL, NULL,
-                                               fortran, NULL);
+    r=(PyArrayObject*)PyArray_NewFromDescr(&PyArray_Type, typecode,
+                                           nd, d,
+                                           NULL, NULL,
+                                           fortran, NULL);
 
-        if(!r) return NULL;
-        if(Assign_Array(r,s) == -1) {
-                Py_DECREF(r);
-                return NULL;
-        }
-        return (PyObject*)r;
+    if(!r) return NULL;
+    if(Assign_Array(r,s) == -1) {
+        Py_DECREF(r);
+        return NULL;
+    }
+    return (PyObject*)r;
 }
 
 /* isobject means that we are constructing an
    object array on-purpose with a nested list.
    Only a list is interpreted as a sequence with these rules
- */
+*/
 /* steals reference to typecode */
 static PyObject *
 Array_FromSequence(PyObject *s, PyArray_Descr *typecode, int fortran,
                    int min_depth, int max_depth)
 {
-        PyArrayObject *r;
-        int nd;
-        intp d[MAX_DIMS];
-        int stop_at_string;
-        int stop_at_tuple;
-        int check_it;
-        int type = typecode->type_num;
-        int itemsize = typecode->elsize;
-
-        check_it = (typecode->type != PyArray_CHARLTR);
-
-        stop_at_string = ((type == PyArray_OBJECT) ||   
-                          (type == PyArray_STRING && 
-                           typecode->type == PyArray_STRINGLTR) ||     
-                          (type == PyArray_UNICODE) ||  
-                          (type == PyArray_VOID));
-        
-        stop_at_tuple = (type == PyArray_VOID && (typecode->names       \
-                                                  || typecode->subarray));
-        
-        if (!((nd=discover_depth(s, MAX_DIMS+1, stop_at_string,
-                                 stop_at_tuple)) > 0)) {
-                if (nd==0)
-                        return Array_FromPyScalar(s, typecode);
-                PyErr_SetString(PyExc_ValueError,
-                                "invalid input sequence");
-                goto fail;
-        }
+    PyArrayObject *r;
+    int nd;
+    intp d[MAX_DIMS];
+    int stop_at_string;
+    int stop_at_tuple;
+    int check_it;
+    int type = typecode->type_num;
+    int itemsize = typecode->elsize;
+
+    check_it = (typecode->type != PyArray_CHARLTR);
+
+    stop_at_string = ((type == PyArray_OBJECT) ||
+                      (type == PyArray_STRING &&
+                       typecode->type == PyArray_STRINGLTR) ||
+                      (type == PyArray_UNICODE) ||
+                      (type == PyArray_VOID));
+
+    stop_at_tuple = (type == PyArray_VOID && (typecode->names       \
+                                              || typecode->subarray));
+
+    if (!((nd=discover_depth(s, MAX_DIMS+1, stop_at_string,
+                             stop_at_tuple)) > 0)) {
+        if (nd==0)
+            return Array_FromPyScalar(s, typecode);
+        PyErr_SetString(PyExc_ValueError,
+                        "invalid input sequence");
+        goto fail;
+    }
 
-        if (max_depth && PyTypeNum_ISOBJECT(type) && (nd > max_depth)) {
-                nd = max_depth;
-        }
+    if (max_depth && PyTypeNum_ISOBJECT(type) && (nd > max_depth)) {
+        nd = max_depth;
+    }
 
-        if ((max_depth && nd > max_depth) ||    \
-            (min_depth && nd < min_depth)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "invalid number of dimensions");
-                goto fail;
-        }
+    if ((max_depth && nd > max_depth) ||    \
+        (min_depth && nd < min_depth)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "invalid number of dimensions");
+        goto fail;
+    }
 
-        if(discover_dimensions(s,nd,d, check_it) == -1) goto fail;
+    if(discover_dimensions(s,nd,d, check_it) == -1) goto fail;
 
-        if (typecode->type == PyArray_CHARLTR && nd > 0 && d[nd-1]==1) {
-                nd = nd-1;
-        }
+    if (typecode->type == PyArray_CHARLTR && nd > 0 && d[nd-1]==1) {
+        nd = nd-1;
+    }
 
-        if (itemsize == 0 && PyTypeNum_ISEXTENDED(type)) {
-                if (discover_itemsize(s, nd, &itemsize) == -1) goto fail;
-                if (type == PyArray_UNICODE) itemsize*=4;
-        }
+    if (itemsize == 0 && PyTypeNum_ISEXTENDED(type)) {
+        if (discover_itemsize(s, nd, &itemsize) == -1) goto fail;
+        if (type == PyArray_UNICODE) itemsize*=4;
+    }
 
-        if (itemsize != typecode->elsize) {
-                PyArray_DESCR_REPLACE(typecode);
-                typecode->elsize = itemsize;
-        }
+    if (itemsize != typecode->elsize) {
+        PyArray_DESCR_REPLACE(typecode);
+        typecode->elsize = itemsize;
+    }
 
-        r=(PyArrayObject*)PyArray_NewFromDescr(&PyArray_Type, typecode,
-                                               nd, d,
-                                               NULL, NULL,
-                                               fortran, NULL);
+    r=(PyArrayObject*)PyArray_NewFromDescr(&PyArray_Type, typecode,
+                                           nd, d,
+                                           NULL, NULL,
+                                           fortran, NULL);
 
-        if(!r) return NULL;
-        if(Assign_Array(r,s) == -1) {
-                Py_DECREF(r);
-                return NULL;
-        }
-        return (PyObject*)r;
+    if(!r) return NULL;
+    if(Assign_Array(r,s) == -1) {
+        Py_DECREF(r);
+        return NULL;
+    }
+    return (PyObject*)r;
 
  fail:
-        Py_DECREF(typecode);
-        return NULL;
+    Py_DECREF(typecode);
+    return NULL;
 }
 
 
 /*OBJECT_API
- Is the typenum valid?
+  Is the typenum valid?
 */
 static int
 PyArray_ValidType(int type)
 {
-        PyArray_Descr *descr;
-        int res=TRUE;
+    PyArray_Descr *descr;
+    int res=TRUE;
 
-        descr = PyArray_DescrFromType(type);
-        if (descr==NULL) res = FALSE;
-        Py_DECREF(descr);
-        return res;
+    descr = PyArray_DescrFromType(type);
+    if (descr==NULL) res = FALSE;
+    Py_DECREF(descr);
+    return res;
 }
 
 /* For backward compatibility */
 
 /* steals reference to at --- cannot be NULL*/
 /*OBJECT_API
- Cast an array using typecode structure.
+  Cast an array using typecode structure.
 */
 static PyObject *
 PyArray_CastToType(PyArrayObject *mp, PyArray_Descr *at, int fortran)
 {
-        PyObject *out;
-        int ret;
-        PyArray_Descr *mpd;
-
-        mpd = mp->descr;
-
-        if (((mpd == at) || ((mpd->type_num == at->type_num) &&         \
-                             PyArray_EquivByteorders(mpd->byteorder,\
-                                                     at->byteorder) &&  \
-                             ((mpd->elsize == at->elsize) ||            \
-                              (at->elsize==0)))) &&                     \
-            PyArray_ISBEHAVED_RO(mp)) {
-                Py_DECREF(at);
-                Py_INCREF(mp);
-                return (PyObject *)mp;
-        }
-
-        if (at->elsize == 0) {
-                PyArray_DESCR_REPLACE(at);
-                if (at == NULL) return NULL;
-                if (mpd->type_num == PyArray_STRING &&  \
-                    at->type_num == PyArray_UNICODE)
-                        at->elsize = mpd->elsize << 2;
-                if (mpd->type_num == PyArray_UNICODE &&
-                    at->type_num == PyArray_STRING)
-                        at->elsize = mpd->elsize >> 2;
-                if (at->type_num == PyArray_VOID)
-                        at->elsize = mpd->elsize;
-        }
-
-        out = PyArray_NewFromDescr(mp->ob_type, at,
-                                   mp->nd,
-                                   mp->dimensions,
-                                   NULL, NULL,
-                                   fortran,
-                                   (PyObject *)mp);
-
-        if (out == NULL) return NULL;
-        ret = PyArray_CastTo((PyArrayObject *)out, mp);
-        if (ret != -1) return out;
-
-        Py_DECREF(out);
-        return NULL;
+    PyObject *out;
+    int ret;
+    PyArray_Descr *mpd;
+
+    mpd = mp->descr;
+
+    if (((mpd == at) || ((mpd->type_num == at->type_num) &&         \
+                         PyArray_EquivByteorders(mpd->byteorder,\
+                                                 at->byteorder) &&  \
+                         ((mpd->elsize == at->elsize) ||            \
+                          (at->elsize==0)))) &&                     \
+        PyArray_ISBEHAVED_RO(mp)) {
+        Py_DECREF(at);
+        Py_INCREF(mp);
+        return (PyObject *)mp;
+    }
+
+    if (at->elsize == 0) {
+        PyArray_DESCR_REPLACE(at);
+        if (at == NULL) return NULL;
+        if (mpd->type_num == PyArray_STRING &&  \
+            at->type_num == PyArray_UNICODE)
+            at->elsize = mpd->elsize << 2;
+        if (mpd->type_num == PyArray_UNICODE &&
+            at->type_num == PyArray_STRING)
+            at->elsize = mpd->elsize >> 2;
+        if (at->type_num == PyArray_VOID)
+            at->elsize = mpd->elsize;
+    }
+
+    out = PyArray_NewFromDescr(mp->ob_type, at,
+                               mp->nd,
+                               mp->dimensions,
+                               NULL, NULL,
+                               fortran,
+                               (PyObject *)mp);
+
+    if (out == NULL) return NULL;
+    ret = PyArray_CastTo((PyArrayObject *)out, mp);
+    if (ret != -1) return out;
+
+    Py_DECREF(out);
+    return NULL;
 
 }
 
 /*OBJECT_API
-   Get a cast function to cast from the input descriptor to the
-   output type_number (must be a registered data-type).
-   Returns NULL if un-successful.
+  Get a cast function to cast from the input descriptor to the
+  output type_number (must be a registered data-type).
+  Returns NULL if un-successful.
 */
 static PyArray_VectorUnaryFunc *
 PyArray_GetCastFunc(PyArray_Descr *descr, int type_num)
 {
-        PyArray_VectorUnaryFunc *castfunc=NULL;
-        if (type_num < PyArray_NTYPES) {
-                castfunc = descr->f->cast[type_num];
-        }
-        if (castfunc == NULL) {
-                PyObject *obj = descr->f->castdict;
-                if (obj && PyDict_Check(obj)) {
-                        PyObject *key;
-                        PyObject *cobj;
-                        key = PyInt_FromLong(type_num);
-                        cobj = PyDict_GetItem(obj, key);
-                        Py_DECREF(key);
-                        if (PyCObject_Check(cobj)) {
-                                castfunc = PyCObject_AsVoidPtr(cobj);
-                        }
-                }
-                if (castfunc) return castfunc;
+    PyArray_VectorUnaryFunc *castfunc=NULL;
+    if (type_num < PyArray_NTYPES) {
+        castfunc = descr->f->cast[type_num];
+    }
+    if (castfunc == NULL) {
+        PyObject *obj = descr->f->castdict;
+        if (obj && PyDict_Check(obj)) {
+            PyObject *key;
+            PyObject *cobj;
+            key = PyInt_FromLong(type_num);
+            cobj = PyDict_GetItem(obj, key);
+            Py_DECREF(key);
+            if (PyCObject_Check(cobj)) {
+                castfunc = PyCObject_AsVoidPtr(cobj);
+            }
         }
-        else return castfunc;
+        if (castfunc) return castfunc;
+    }
+    else return castfunc;
 
-        PyErr_SetString(PyExc_ValueError,
-                        "No cast function available.");
-        return NULL;
+    PyErr_SetString(PyExc_ValueError,
+                    "No cast function available.");
+    return NULL;
 }
 
 /* Reference counts:
@@ -7563,129 +7562,129 @@ _strided_buffered_cast(char *dptr, intp dstride, int delsize, int dswap,
                        PyArray_VectorUnaryFunc *castfunc,
                        PyArrayObject *dest, PyArrayObject *src)
 {
-        int i;
-        if (N <= bufsize) {
-                /* 1. copy input to buffer and swap
-                   2. cast input to output
-                   3. swap output if necessary and copy from output buffer
-                */
-                scopyfunc(buffers[1], selsize, sptr, sstride, N, sswap, src);
-                castfunc(buffers[1], buffers[0], N, src, dest);
-                dcopyfunc(dptr, dstride, buffers[0], delsize, N, dswap, dest);
-                return;
-        }
-
-        /* otherwise we need to divide up into bufsize pieces */
-        i = 0;
-        while(N > 0) {
-                int newN;
-                newN = MIN(N, bufsize);
-                _strided_buffered_cast(dptr+i*dstride, dstride, delsize,
-                                       dswap, dcopyfunc,
-                                       sptr+i*sstride, sstride, selsize,
-                                       sswap, scopyfunc,
-                                       newN, buffers, bufsize, castfunc, dest, src);
-                i += newN;
-                N -= bufsize;
-        }
+    int i;
+    if (N <= bufsize) {
+        /* 1. copy input to buffer and swap
+           2. cast input to output
+           3. swap output if necessary and copy from output buffer
+        */
+        scopyfunc(buffers[1], selsize, sptr, sstride, N, sswap, src);
+        castfunc(buffers[1], buffers[0], N, src, dest);
+        dcopyfunc(dptr, dstride, buffers[0], delsize, N, dswap, dest);
         return;
+    }
+
+    /* otherwise we need to divide up into bufsize pieces */
+    i = 0;
+    while(N > 0) {
+        int newN;
+        newN = MIN(N, bufsize);
+        _strided_buffered_cast(dptr+i*dstride, dstride, delsize,
+                               dswap, dcopyfunc,
+                               sptr+i*sstride, sstride, selsize,
+                               sswap, scopyfunc,
+                               newN, buffers, bufsize, castfunc, dest, src);
+        i += newN;
+        N -= bufsize;
+    }
+    return;
 }
 
 static int
 _broadcast_cast(PyArrayObject *out, PyArrayObject *in,
                 PyArray_VectorUnaryFunc *castfunc, int iswap, int oswap)
 {
-        int delsize, selsize, maxaxis, i, N;
-        PyArrayMultiIterObject *multi;
-        intp maxdim, ostrides, istrides;
-        char *buffers[2];
-        PyArray_CopySwapNFunc *ocopyfunc, *icopyfunc;
-        char *obptr;
+    int delsize, selsize, maxaxis, i, N;
+    PyArrayMultiIterObject *multi;
+    intp maxdim, ostrides, istrides;
+    char *buffers[2];
+    PyArray_CopySwapNFunc *ocopyfunc, *icopyfunc;
+    char *obptr;
 
-        NPY_BEGIN_THREADS_DEF
+    NPY_BEGIN_THREADS_DEF
 
         delsize = PyArray_ITEMSIZE(out);
-        selsize = PyArray_ITEMSIZE(in);
-        multi = (PyArrayMultiIterObject *)PyArray_MultiIterNew(2, out, in);
-        if (multi == NULL) return -1;
-
-        if (multi->size != PyArray_SIZE(out)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "array dimensions are not "\
-                                "compatible for copy");
-                Py_DECREF(multi);
-                return -1;
-        }
+    selsize = PyArray_ITEMSIZE(in);
+    multi = (PyArrayMultiIterObject *)PyArray_MultiIterNew(2, out, in);
+    if (multi == NULL) return -1;
 
-        icopyfunc = in->descr->f->copyswapn;
-        ocopyfunc = out->descr->f->copyswapn;
-        maxaxis = PyArray_RemoveSmallest(multi);
-        if (maxaxis < 0) { /* cast 1 0-d array to another */
-                N = 1;
-                maxdim = 1;
-                ostrides = delsize;
-                istrides = selsize;
-        }
-        else {
-                maxdim = multi->dimensions[maxaxis];
-                N = (int) (MIN(maxdim, PyArray_BUFSIZE));
-                ostrides = multi->iters[0]->strides[maxaxis];
-                istrides = multi->iters[1]->strides[maxaxis];
+    if (multi->size != PyArray_SIZE(out)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "array dimensions are not "\
+                        "compatible for copy");
+        Py_DECREF(multi);
+        return -1;
+    }
 
-        }
-        buffers[0] = _pya_malloc(N*delsize);
-        if (buffers[0] == NULL) {
-                PyErr_NoMemory();
-                return -1;
-        }
-        buffers[1] = _pya_malloc(N*selsize);
-        if (buffers[1] == NULL) {
-                _pya_free(buffers[0]);
-                PyErr_NoMemory();
-                return -1;
-        }
-        if (PyDataType_FLAGCHK(out->descr, NPY_NEEDS_INIT))
-                memset(buffers[0], 0, N*delsize);
-        if (PyDataType_FLAGCHK(in->descr, NPY_NEEDS_INIT))
-                memset(buffers[1], 0, N*selsize);
+    icopyfunc = in->descr->f->copyswapn;
+    ocopyfunc = out->descr->f->copyswapn;
+    maxaxis = PyArray_RemoveSmallest(multi);
+    if (maxaxis < 0) { /* cast 1 0-d array to another */
+        N = 1;
+        maxdim = 1;
+        ostrides = delsize;
+        istrides = selsize;
+    }
+    else {
+        maxdim = multi->dimensions[maxaxis];
+        N = (int) (MIN(maxdim, PyArray_BUFSIZE));
+        ostrides = multi->iters[0]->strides[maxaxis];
+        istrides = multi->iters[1]->strides[maxaxis];
+
+    }
+    buffers[0] = _pya_malloc(N*delsize);
+    if (buffers[0] == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    buffers[1] = _pya_malloc(N*selsize);
+    if (buffers[1] == NULL) {
+        _pya_free(buffers[0]);
+        PyErr_NoMemory();
+        return -1;
+    }
+    if (PyDataType_FLAGCHK(out->descr, NPY_NEEDS_INIT))
+        memset(buffers[0], 0, N*delsize);
+    if (PyDataType_FLAGCHK(in->descr, NPY_NEEDS_INIT))
+        memset(buffers[1], 0, N*selsize);
 
 #if NPY_ALLOW_THREADS
-        if (PyArray_ISNUMBER(in) && PyArray_ISNUMBER(out)) {
-                NPY_BEGIN_THREADS
-                        }
+    if (PyArray_ISNUMBER(in) && PyArray_ISNUMBER(out)) {
+        NPY_BEGIN_THREADS
+            }
 #endif
 
-        while(multi->index < multi->size) {
-                _strided_buffered_cast(multi->iters[0]->dataptr,
-                                       ostrides,
-                                       delsize, oswap, ocopyfunc,
-                                       multi->iters[1]->dataptr,
-                                       istrides,
-                                       selsize, iswap, icopyfunc,
-                                       maxdim, buffers, N,
-                                       castfunc, out, in);
-                PyArray_MultiIter_NEXT(multi);
-        }
+    while(multi->index < multi->size) {
+        _strided_buffered_cast(multi->iters[0]->dataptr,
+                               ostrides,
+                               delsize, oswap, ocopyfunc,
+                               multi->iters[1]->dataptr,
+                               istrides,
+                               selsize, iswap, icopyfunc,
+                               maxdim, buffers, N,
+                               castfunc, out, in);
+        PyArray_MultiIter_NEXT(multi);
+    }
 #if NPY_ALLOW_THREADS
-        if (PyArray_ISNUMBER(in) && PyArray_ISNUMBER(out)) {
-                NPY_END_THREADS
-                        }
+    if (PyArray_ISNUMBER(in) && PyArray_ISNUMBER(out)) {
+        NPY_END_THREADS
+            }
 #endif
-        Py_DECREF(multi);
-        if (PyDataType_REFCHK(in->descr)) {
-                obptr = buffers[1];
-                for (i=0; i<N; i++, obptr+=selsize)
-                        PyArray_Item_XDECREF(obptr, out->descr);
-        }
-        if (PyDataType_REFCHK(out->descr)) {
-                obptr = buffers[0];
-                for (i=0; i<N; i++, obptr+=delsize)
-                        PyArray_Item_XDECREF(obptr, out->descr);
-        }
-        _pya_free(buffers[0]);
-        _pya_free(buffers[1]);
-        if (PyErr_Occurred()) return -1;
-        return 0;
+    Py_DECREF(multi);
+    if (PyDataType_REFCHK(in->descr)) {
+        obptr = buffers[1];
+        for (i=0; i<N; i++, obptr+=selsize)
+            PyArray_Item_XDECREF(obptr, out->descr);
+    }
+    if (PyDataType_REFCHK(out->descr)) {
+        obptr = buffers[0];
+        for (i=0; i<N; i++, obptr+=delsize)
+            PyArray_Item_XDECREF(obptr, out->descr);
+    }
+    _pya_free(buffers[0]);
+    _pya_free(buffers[1]);
+    if (PyErr_Occurred()) return -1;
+    return 0;
 }
 
 
@@ -7697,64 +7696,64 @@ _broadcast_cast(PyArrayObject *out, PyArrayObject *in,
 */
 
 /*OBJECT_API
- Cast to an already created array.
+  Cast to an already created array.
 */
 static int
 PyArray_CastTo(PyArrayObject *out, PyArrayObject *mp)
 {
 
-        int simple;
-        int same;
-        PyArray_VectorUnaryFunc *castfunc=NULL;
-        int mpsize = PyArray_SIZE(mp);
-        int iswap, oswap;
+    int simple;
+    int same;
+    PyArray_VectorUnaryFunc *castfunc=NULL;
+    int mpsize = PyArray_SIZE(mp);
+    int iswap, oswap;
 
-        NPY_BEGIN_THREADS_DEF
+    NPY_BEGIN_THREADS_DEF
 
         if (mpsize == 0) return 0;
-        if (!PyArray_ISWRITEABLE(out)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "output array is not writeable");
-                return -1;
-        }
+    if (!PyArray_ISWRITEABLE(out)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "output array is not writeable");
+        return -1;
+    }
 
-        castfunc = PyArray_GetCastFunc(mp->descr, out->descr->type_num);
-        if (castfunc == NULL) return -1;
+    castfunc = PyArray_GetCastFunc(mp->descr, out->descr->type_num);
+    if (castfunc == NULL) return -1;
 
 
-        same = PyArray_SAMESHAPE(out, mp);
-        simple = same && ((PyArray_ISCARRAY_RO(mp) && PyArray_ISCARRAY(out)) ||
-                          (PyArray_ISFARRAY_RO(mp) && PyArray_ISFARRAY(out)));
+    same = PyArray_SAMESHAPE(out, mp);
+    simple = same && ((PyArray_ISCARRAY_RO(mp) && PyArray_ISCARRAY(out)) ||
+                      (PyArray_ISFARRAY_RO(mp) && PyArray_ISFARRAY(out)));
 
-        if (simple) {
+    if (simple) {
 
 #if NPY_ALLOW_THREADS
-                if (PyArray_ISNUMBER(mp) && PyArray_ISNUMBER(out)) {
-                        NPY_BEGIN_THREADS }
+        if (PyArray_ISNUMBER(mp) && PyArray_ISNUMBER(out)) {
+            NPY_BEGIN_THREADS }
 #endif
-                castfunc(mp->data, out->data, mpsize, mp, out);
+        castfunc(mp->data, out->data, mpsize, mp, out);
 
 #if NPY_ALLOW_THREADS
-                if (PyArray_ISNUMBER(mp) && PyArray_ISNUMBER(out)) {
-                        NPY_END_THREADS   }
+        if (PyArray_ISNUMBER(mp) && PyArray_ISNUMBER(out)) {
+            NPY_END_THREADS   }
 #endif
-                if (!PyArray_ISNUMBER(mp) && PyErr_Occurred()) return -1;
-        }
+        if (!PyArray_ISNUMBER(mp) && PyErr_Occurred()) return -1;
+    }
 
-        /* If the input or output is OBJECT, STRING, UNICODE, or VOID */
-        /*  then getitem and setitem are used for the cast */
-        /*  and byteswapping is handled by those methods */
+    /* If the input or output is OBJECT, STRING, UNICODE, or VOID */
+    /*  then getitem and setitem are used for the cast */
+    /*  and byteswapping is handled by those methods */
 
-        if (PyArray_ISFLEXIBLE(mp) || PyArray_ISOBJECT(mp) || PyArray_ISOBJECT(out) ||
-            PyArray_ISFLEXIBLE(out)) {
-                iswap = oswap = 0;
-        }
-        else {
-                iswap = PyArray_ISBYTESWAPPED(mp);
-                oswap = PyArray_ISBYTESWAPPED(out);
-        }
+    if (PyArray_ISFLEXIBLE(mp) || PyArray_ISOBJECT(mp) || PyArray_ISOBJECT(out) ||
+        PyArray_ISFLEXIBLE(out)) {
+        iswap = oswap = 0;
+    }
+    else {
+        iswap = PyArray_ISBYTESWAPPED(mp);
+        oswap = PyArray_ISBYTESWAPPED(out);
+    }
 
-        return _broadcast_cast(out, mp, castfunc, iswap, oswap);
+    return _broadcast_cast(out, mp, castfunc, iswap, oswap);
 }
 
 
@@ -7762,142 +7761,142 @@ static int
 _bufferedcast(PyArrayObject *out, PyArrayObject *in,
               PyArray_VectorUnaryFunc *castfunc)
 {
-        char *inbuffer, *bptr, *optr;
-        char *outbuffer=NULL;
-        PyArrayIterObject *it_in=NULL, *it_out=NULL;
-        register intp i, index;
-        intp ncopies = PyArray_SIZE(out) / PyArray_SIZE(in);
-        int elsize=in->descr->elsize;
-        int nels = PyArray_BUFSIZE;
-        int el;
-        int inswap, outswap=0;
-        int obuf=!PyArray_ISCARRAY(out);
-        int oelsize = out->descr->elsize;
-        PyArray_CopySwapFunc *in_csn;
-        PyArray_CopySwapFunc *out_csn;
-        int retval = -1;
-
-        in_csn = in->descr->f->copyswap;
-        out_csn = out->descr->f->copyswap;
-
-        /* If the input or output is STRING, UNICODE, or VOID */
-        /*  then getitem and setitem are used for the cast */
-        /*  and byteswapping is handled by those methods */
-
-        inswap = !(PyArray_ISFLEXIBLE(in) || PyArray_ISNOTSWAPPED(in));
-
-        inbuffer = PyDataMem_NEW(PyArray_BUFSIZE*elsize);
-        if (inbuffer == NULL) return -1;
-        if (PyArray_ISOBJECT(in))
-                memset(inbuffer, 0, PyArray_BUFSIZE*elsize);
-        it_in = (PyArrayIterObject *)PyArray_IterNew((PyObject *)in);
-        if (it_in == NULL) goto exit;
-
-        if (obuf) {
-                outswap = !(PyArray_ISFLEXIBLE(out) || \
-                            PyArray_ISNOTSWAPPED(out));
-                outbuffer = PyDataMem_NEW(PyArray_BUFSIZE*oelsize);
-                if (outbuffer == NULL) goto exit;
-                if (PyArray_ISOBJECT(out))
-                        memset(outbuffer, 0, PyArray_BUFSIZE*oelsize);
-
-                it_out = (PyArrayIterObject *)PyArray_IterNew((PyObject *)out);
-                if (it_out == NULL) goto exit;
-
-                nels = MIN(nels, PyArray_BUFSIZE);
-        }
-
-        optr = (obuf) ? outbuffer: out->data;
-        bptr = inbuffer;
-        el = 0;
-        while(ncopies--) {
-                index = it_in->size;
-                PyArray_ITER_RESET(it_in);
-                while(index--) {
-                        in_csn(bptr, it_in->dataptr, inswap, in);
-                        bptr += elsize;
-                        PyArray_ITER_NEXT(it_in);
-                        el += 1;
-                        if ((el == nels) || (index == 0)) {
-                                /* buffer filled, do cast */
-
-                                castfunc(inbuffer, optr, el, in, out);
-
-                                if (obuf) {
-                                        /* Copy from outbuffer to array */
-                                        for(i=0; i<el; i++) {
-                                                out_csn(it_out->dataptr,
-                                                        optr, outswap,
-                                                        out);
-                                                optr += oelsize;
-                                                PyArray_ITER_NEXT(it_out);
-                                        }
-                                        optr = outbuffer;
-                                }
-                                else {
-                                        optr += out->descr->elsize * nels;
-                                }
-                                el = 0;
-                                bptr = inbuffer;
-                        }
+    char *inbuffer, *bptr, *optr;
+    char *outbuffer=NULL;
+    PyArrayIterObject *it_in=NULL, *it_out=NULL;
+    register intp i, index;
+    intp ncopies = PyArray_SIZE(out) / PyArray_SIZE(in);
+    int elsize=in->descr->elsize;
+    int nels = PyArray_BUFSIZE;
+    int el;
+    int inswap, outswap=0;
+    int obuf=!PyArray_ISCARRAY(out);
+    int oelsize = out->descr->elsize;
+    PyArray_CopySwapFunc *in_csn;
+    PyArray_CopySwapFunc *out_csn;
+    int retval = -1;
+
+    in_csn = in->descr->f->copyswap;
+    out_csn = out->descr->f->copyswap;
+
+    /* If the input or output is STRING, UNICODE, or VOID */
+    /*  then getitem and setitem are used for the cast */
+    /*  and byteswapping is handled by those methods */
+
+    inswap = !(PyArray_ISFLEXIBLE(in) || PyArray_ISNOTSWAPPED(in));
+
+    inbuffer = PyDataMem_NEW(PyArray_BUFSIZE*elsize);
+    if (inbuffer == NULL) return -1;
+    if (PyArray_ISOBJECT(in))
+        memset(inbuffer, 0, PyArray_BUFSIZE*elsize);
+    it_in = (PyArrayIterObject *)PyArray_IterNew((PyObject *)in);
+    if (it_in == NULL) goto exit;
+
+    if (obuf) {
+        outswap = !(PyArray_ISFLEXIBLE(out) || \
+                    PyArray_ISNOTSWAPPED(out));
+        outbuffer = PyDataMem_NEW(PyArray_BUFSIZE*oelsize);
+        if (outbuffer == NULL) goto exit;
+        if (PyArray_ISOBJECT(out))
+            memset(outbuffer, 0, PyArray_BUFSIZE*oelsize);
+
+        it_out = (PyArrayIterObject *)PyArray_IterNew((PyObject *)out);
+        if (it_out == NULL) goto exit;
+
+        nels = MIN(nels, PyArray_BUFSIZE);
+    }
+
+    optr = (obuf) ? outbuffer: out->data;
+    bptr = inbuffer;
+    el = 0;
+    while(ncopies--) {
+        index = it_in->size;
+        PyArray_ITER_RESET(it_in);
+        while(index--) {
+            in_csn(bptr, it_in->dataptr, inswap, in);
+            bptr += elsize;
+            PyArray_ITER_NEXT(it_in);
+            el += 1;
+            if ((el == nels) || (index == 0)) {
+                /* buffer filled, do cast */
+
+                castfunc(inbuffer, optr, el, in, out);
+
+                if (obuf) {
+                    /* Copy from outbuffer to array */
+                    for(i=0; i<el; i++) {
+                        out_csn(it_out->dataptr,
+                                optr, outswap,
+                                out);
+                        optr += oelsize;
+                        PyArray_ITER_NEXT(it_out);
+                    }
+                    optr = outbuffer;
+                }
+                else {
+                    optr += out->descr->elsize * nels;
                 }
+                el = 0;
+                bptr = inbuffer;
+            }
         }
-        retval = 0;
+    }
+    retval = 0;
  exit:
-        Py_XDECREF(it_in);
-        PyDataMem_FREE(inbuffer);
-        PyDataMem_FREE(outbuffer);
-        if (obuf) {
-                Py_XDECREF(it_out);
-        }
-        return retval;
+    Py_XDECREF(it_in);
+    PyDataMem_FREE(inbuffer);
+    PyDataMem_FREE(outbuffer);
+    if (obuf) {
+        Py_XDECREF(it_out);
+    }
+    return retval;
 }
 
 /*OBJECT_API
- Cast to an already created array.  Arrays don't have to be "broadcastable"
- Only requirement is they have the same number of elements.
+  Cast to an already created array.  Arrays don't have to be "broadcastable"
+  Only requirement is they have the same number of elements.
 */
 static int
 PyArray_CastAnyTo(PyArrayObject *out, PyArrayObject *mp)
 {
-        int simple;
-        PyArray_VectorUnaryFunc *castfunc=NULL;
-        int mpsize = PyArray_SIZE(mp);
+    int simple;
+    PyArray_VectorUnaryFunc *castfunc=NULL;
+    int mpsize = PyArray_SIZE(mp);
 
-        if (mpsize == 0) return 0;
-        if (!PyArray_ISWRITEABLE(out)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "output array is not writeable");
-                return -1;
-        }
+    if (mpsize == 0) return 0;
+    if (!PyArray_ISWRITEABLE(out)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "output array is not writeable");
+        return -1;
+    }
 
-        if (!(mpsize == PyArray_SIZE(out))) {
-                PyErr_SetString(PyExc_ValueError,
-                                "arrays must have the same number of"
-                                " elements for the cast.");
-                return -1;
-        }
+    if (!(mpsize == PyArray_SIZE(out))) {
+        PyErr_SetString(PyExc_ValueError,
+                        "arrays must have the same number of"
+                        " elements for the cast.");
+        return -1;
+    }
 
-        castfunc = PyArray_GetCastFunc(mp->descr, out->descr->type_num);
-        if (castfunc == NULL) return -1;
+    castfunc = PyArray_GetCastFunc(mp->descr, out->descr->type_num);
+    if (castfunc == NULL) return -1;
 
 
-        simple = ((PyArray_ISCARRAY_RO(mp) && PyArray_ISCARRAY(out)) ||
-                  (PyArray_ISFARRAY_RO(mp) && PyArray_ISFARRAY(out)));
+    simple = ((PyArray_ISCARRAY_RO(mp) && PyArray_ISCARRAY(out)) ||
+              (PyArray_ISFARRAY_RO(mp) && PyArray_ISFARRAY(out)));
 
-        if (simple) {
-                castfunc(mp->data, out->data, mpsize, mp, out);
-                return 0;
-        }
+    if (simple) {
+        castfunc(mp->data, out->data, mpsize, mp, out);
+        return 0;
+    }
 
-        if (PyArray_SAMESHAPE(out, mp)) {
-                int iswap, oswap;
-                iswap = PyArray_ISBYTESWAPPED(mp) && !PyArray_ISFLEXIBLE(mp);
-                oswap = PyArray_ISBYTESWAPPED(out) && !PyArray_ISFLEXIBLE(out);
-                return _broadcast_cast(out, mp, castfunc, iswap, oswap);
-        }
+    if (PyArray_SAMESHAPE(out, mp)) {
+        int iswap, oswap;
+        iswap = PyArray_ISBYTESWAPPED(mp) && !PyArray_ISFLEXIBLE(mp);
+        oswap = PyArray_ISBYTESWAPPED(out) && !PyArray_ISFLEXIBLE(out);
+        return _broadcast_cast(out, mp, castfunc, iswap, oswap);
+    }
 
-        return _bufferedcast(out, mp, castfunc);
+    return _bufferedcast(out, mp, castfunc);
 }
 
 
@@ -7908,229 +7907,229 @@ static PyObject *
 PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags)
 {
 
-        PyArrayObject *ret=NULL;
-        int itemsize;
-        int copy = 0;
-        int arrflags;
-        PyArray_Descr *oldtype;
-        char *msg = "cannot copy back to a read-only array";
-        PyTypeObject *subtype;
+    PyArrayObject *ret=NULL;
+    int itemsize;
+    int copy = 0;
+    int arrflags;
+    PyArray_Descr *oldtype;
+    char *msg = "cannot copy back to a read-only array";
+    PyTypeObject *subtype;
 
-        oldtype = PyArray_DESCR(arr);
+    oldtype = PyArray_DESCR(arr);
 
-        subtype = arr->ob_type;
+    subtype = arr->ob_type;
 
-        if (newtype == NULL) {newtype = oldtype; Py_INCREF(oldtype);}
+    if (newtype == NULL) {newtype = oldtype; Py_INCREF(oldtype);}
+    itemsize = newtype->elsize;
+    if (itemsize == 0) {
+        PyArray_DESCR_REPLACE(newtype);
+        if (newtype == NULL) return NULL;
+        newtype->elsize = oldtype->elsize;
         itemsize = newtype->elsize;
-        if (itemsize == 0) {
-                PyArray_DESCR_REPLACE(newtype);
-                if (newtype == NULL) return NULL;
-                newtype->elsize = oldtype->elsize;
-                itemsize = newtype->elsize;
-        }
+    }
 
-        /* Can't cast unless ndim-0 array, FORCECAST is specified
-           or the cast is safe.
-        */
-        if (!(flags & FORCECAST) && !PyArray_NDIM(arr)==0 && 
-            !PyArray_CanCastTo(oldtype, newtype)) {
+    /* Can't cast unless ndim-0 array, FORCECAST is specified
+       or the cast is safe.
+    */
+    if (!(flags & FORCECAST) && !PyArray_NDIM(arr)==0 &&
+        !PyArray_CanCastTo(oldtype, newtype)) {
+        Py_DECREF(newtype);
+        PyErr_SetString(PyExc_TypeError,
+                        "array cannot be safely cast "  \
+                        "to required type");
+        return NULL;
+    }
+
+    /* Don't copy if sizes are compatible */
+    if ((flags & ENSURECOPY) || PyArray_EquivTypes(oldtype, newtype)) {
+        arrflags = arr->flags;
+
+        copy = (flags & ENSURECOPY) || \
+            ((flags & CONTIGUOUS) && (!(arrflags & CONTIGUOUS))) \
+            || ((flags & ALIGNED) && (!(arrflags & ALIGNED))) \
+            || (arr->nd > 1 &&                              \
+                ((flags & FORTRAN) && (!(arrflags & FORTRAN)))) \
+            || ((flags & WRITEABLE) && (!(arrflags & WRITEABLE)));
+
+        if (copy) {
+            if ((flags & UPDATEIFCOPY) && \
+                (!PyArray_ISWRITEABLE(arr))) {
                 Py_DECREF(newtype);
-                PyErr_SetString(PyExc_TypeError,
-                                "array cannot be safely cast "  \
-                                "to required type");
+                PyErr_SetString(PyExc_ValueError, msg);
                 return NULL;
+            }
+            if ((flags & ENSUREARRAY)) {
+                subtype = &PyArray_Type;
+            }
+            ret = (PyArrayObject *)         \
+                PyArray_NewFromDescr(subtype, newtype,
+                                     arr->nd,
+                                     arr->dimensions,
+                                     NULL, NULL,
+                                     flags & FORTRAN,
+                                     (PyObject *)arr);
+            if (ret == NULL) return NULL;
+            if (PyArray_CopyInto(ret, arr) == -1)
+                {Py_DECREF(ret); return NULL;}
+            if (flags & UPDATEIFCOPY)  {
+                ret->flags |= UPDATEIFCOPY;
+                ret->base = (PyObject *)arr;
+                PyArray_FLAGS(ret->base) &= ~WRITEABLE;
+                Py_INCREF(arr);
+            }
         }
-        
-        /* Don't copy if sizes are compatible */
-        if ((flags & ENSURECOPY) || PyArray_EquivTypes(oldtype, newtype)) {
-                arrflags = arr->flags;
-
-                copy = (flags & ENSURECOPY) || \
-                        ((flags & CONTIGUOUS) && (!(arrflags & CONTIGUOUS))) \
-                        || ((flags & ALIGNED) && (!(arrflags & ALIGNED))) \
-                        || (arr->nd > 1 &&                              \
-                            ((flags & FORTRAN) && (!(arrflags & FORTRAN)))) \
-                        || ((flags & WRITEABLE) && (!(arrflags & WRITEABLE)));
-
-                if (copy) {
-                        if ((flags & UPDATEIFCOPY) && \
-                            (!PyArray_ISWRITEABLE(arr))) {
-                                Py_DECREF(newtype);
-                                PyErr_SetString(PyExc_ValueError, msg);
-                                return NULL;
-                        }
-                        if ((flags & ENSUREARRAY)) {
-                                subtype = &PyArray_Type;
-                        }
-                        ret = (PyArrayObject *)         \
-                                PyArray_NewFromDescr(subtype, newtype,
-                                                     arr->nd,
-                                                     arr->dimensions,
-                                                     NULL, NULL,
-                                                     flags & FORTRAN,
-                                                     (PyObject *)arr);
-                        if (ret == NULL) return NULL;
-                        if (PyArray_CopyInto(ret, arr) == -1)
-                                {Py_DECREF(ret); return NULL;}
-                        if (flags & UPDATEIFCOPY)  {
-                                ret->flags |= UPDATEIFCOPY;
-                                ret->base = (PyObject *)arr;
-                                PyArray_FLAGS(ret->base) &= ~WRITEABLE;
-                                Py_INCREF(arr);
-                        }
-                }
-                /* If no copy then just increase the reference
-                   count and return the input */
-                else {
-                        Py_DECREF(newtype);
-                        if ((flags & ENSUREARRAY) && 
-                            !PyArray_CheckExact(arr)) {
-                                Py_INCREF(arr->descr);
-                                ret = (PyArrayObject *)                 \
-                                        PyArray_NewFromDescr(&PyArray_Type,
-                                                             arr->descr,
-                                                             arr->nd,
-                                                             arr->dimensions,
-                                                             arr->strides,
-                                                             arr->data,
-                                                             arr->flags,NULL);
-                                if (ret == NULL) return NULL;
-                                ret->base = (PyObject *)arr;
-                        }
-                        else {
-                                ret = arr;
-                        }
-                        Py_INCREF(arr);
-                }
-        }
-
-        /* The desired output type is different than the input
-           array type and copy was not specified */
+        /* If no copy then just increase the reference
+           count and return the input */
         else {
-                if ((flags & UPDATEIFCOPY) &&                   \
-                    (!PyArray_ISWRITEABLE(arr))) {
-                        Py_DECREF(newtype);
-                        PyErr_SetString(PyExc_ValueError, msg);
-                        return NULL;
-                }
-                if ((flags & ENSUREARRAY)) {
-                        subtype = &PyArray_Type;
-                }
-                ret = (PyArrayObject *)                         \
-                        PyArray_NewFromDescr(subtype, newtype,
-                                             arr->nd, arr->dimensions,
-                                             NULL, NULL,
-                                             flags & FORTRAN,
-                                             (PyObject *)arr);
+            Py_DECREF(newtype);
+            if ((flags & ENSUREARRAY) &&
+                !PyArray_CheckExact(arr)) {
+                Py_INCREF(arr->descr);
+                ret = (PyArrayObject *)                 \
+                    PyArray_NewFromDescr(&PyArray_Type,
+                                         arr->descr,
+                                         arr->nd,
+                                         arr->dimensions,
+                                         arr->strides,
+                                         arr->data,
+                                         arr->flags,NULL);
                 if (ret == NULL) return NULL;
-                if (PyArray_CastTo(ret, arr) < 0) {
-                        Py_DECREF(ret);
-                        return NULL;
-                }
-                if (flags & UPDATEIFCOPY)  {
-                        ret->flags |= UPDATEIFCOPY;
-                        ret->base = (PyObject *)arr;
-                        PyArray_FLAGS(ret->base) &= ~WRITEABLE;
-                        Py_INCREF(arr);
-                }
+                ret->base = (PyObject *)arr;
+            }
+            else {
+                ret = arr;
+            }
+            Py_INCREF(arr);
         }
-        return (PyObject *)ret;
+    }
+
+    /* The desired output type is different than the input
+       array type and copy was not specified */
+    else {
+        if ((flags & UPDATEIFCOPY) &&                   \
+            (!PyArray_ISWRITEABLE(arr))) {
+            Py_DECREF(newtype);
+            PyErr_SetString(PyExc_ValueError, msg);
+            return NULL;
+        }
+        if ((flags & ENSUREARRAY)) {
+            subtype = &PyArray_Type;
+        }
+        ret = (PyArrayObject *)                         \
+            PyArray_NewFromDescr(subtype, newtype,
+                                 arr->nd, arr->dimensions,
+                                 NULL, NULL,
+                                 flags & FORTRAN,
+                                 (PyObject *)arr);
+        if (ret == NULL) return NULL;
+        if (PyArray_CastTo(ret, arr) < 0) {
+            Py_DECREF(ret);
+            return NULL;
+        }
+        if (flags & UPDATEIFCOPY)  {
+            ret->flags |= UPDATEIFCOPY;
+            ret->base = (PyObject *)arr;
+            PyArray_FLAGS(ret->base) &= ~WRITEABLE;
+            Py_INCREF(arr);
+        }
+    }
+    return (PyObject *)ret;
 }
 
 /* new reference */
 static PyArray_Descr *
 _array_typedescr_fromstr(char *str)
 {
-        PyArray_Descr *descr;
-        int type_num;
-        char typechar;
-        int size;
-        char msg[] = "unsupported typestring";
-        int swap;
-        char swapchar;
-
-        swapchar = str[0];
-        str += 1;
-
-#define _MY_FAIL {                                  \
-                PyErr_SetString(PyExc_ValueError, msg); \
-                return NULL;                            \
-        }
-
-        typechar = str[0];
-        size = atoi(str + 1);
-        switch (typechar) {
-        case 'b':
-                if (size == sizeof(Bool))
-                        type_num = PyArray_BOOL;
-                else _MY_FAIL
-                        break;
-        case 'u':
-                if (size == sizeof(uintp))
-                        type_num = PyArray_UINTP;
-                else if (size == sizeof(char))
-                        type_num = PyArray_UBYTE;
-                else if (size == sizeof(short))
-                        type_num = PyArray_USHORT;
-                else if (size == sizeof(ulong))
-                        type_num = PyArray_ULONG;
-                else if (size == sizeof(int))
-                        type_num = PyArray_UINT;
-                else if (size == sizeof(ulonglong))
-                        type_num = PyArray_ULONGLONG;
-                else _MY_FAIL
-                        break;
-        case 'i':
-                if (size == sizeof(intp))
-                        type_num = PyArray_INTP;
-                else if (size == sizeof(char))
-                    type_num = PyArray_BYTE;
-                else if (size == sizeof(short))
-                        type_num = PyArray_SHORT;
-                else if (size == sizeof(long))
-                        type_num = PyArray_LONG;
-                else if (size == sizeof(int))
-                        type_num = PyArray_INT;
-                else if (size == sizeof(longlong))
-                        type_num = PyArray_LONGLONG;
-                else _MY_FAIL
-                        break;
-        case 'f':
-                if (size == sizeof(float))
-                        type_num = PyArray_FLOAT;
-                else if (size == sizeof(double))
-                        type_num = PyArray_DOUBLE;
-                else if (size == sizeof(longdouble))
-                        type_num = PyArray_LONGDOUBLE;
-                else _MY_FAIL
-                        break;
-        case 'c':
-                if (size == sizeof(float)*2)
-                        type_num = PyArray_CFLOAT;
-                else if (size == sizeof(double)*2)
-                        type_num = PyArray_CDOUBLE;
-                else if (size == sizeof(longdouble)*2)
-                        type_num = PyArray_CLONGDOUBLE;
-                else _MY_FAIL
-                        break;
-        case 'O':
-                if (size == sizeof(PyObject *))
-                        type_num = PyArray_OBJECT;
-                else _MY_FAIL
-                break;
-        case PyArray_STRINGLTR:
-                type_num = PyArray_STRING;
-                break;
-        case PyArray_UNICODELTR:
-                type_num = PyArray_UNICODE;
-                size <<= 2;
-                break;
-        case 'V':
-                type_num = PyArray_VOID;
-                break;
-        default:
-                _MY_FAIL
-        }
+    PyArray_Descr *descr;
+    int type_num;
+    char typechar;
+    int size;
+    char msg[] = "unsupported typestring";
+    int swap;
+    char swapchar;
+
+    swapchar = str[0];
+    str += 1;
+
+#define _MY_FAIL {                              \
+        PyErr_SetString(PyExc_ValueError, msg); \
+        return NULL;                            \
+    }
+
+    typechar = str[0];
+    size = atoi(str + 1);
+    switch (typechar) {
+    case 'b':
+        if (size == sizeof(Bool))
+            type_num = PyArray_BOOL;
+        else _MY_FAIL
+                 break;
+    case 'u':
+        if (size == sizeof(uintp))
+            type_num = PyArray_UINTP;
+        else if (size == sizeof(char))
+            type_num = PyArray_UBYTE;
+        else if (size == sizeof(short))
+            type_num = PyArray_USHORT;
+        else if (size == sizeof(ulong))
+            type_num = PyArray_ULONG;
+        else if (size == sizeof(int))
+            type_num = PyArray_UINT;
+        else if (size == sizeof(ulonglong))
+            type_num = PyArray_ULONGLONG;
+        else _MY_FAIL
+                 break;
+    case 'i':
+        if (size == sizeof(intp))
+            type_num = PyArray_INTP;
+        else if (size == sizeof(char))
+            type_num = PyArray_BYTE;
+        else if (size == sizeof(short))
+            type_num = PyArray_SHORT;
+        else if (size == sizeof(long))
+            type_num = PyArray_LONG;
+        else if (size == sizeof(int))
+            type_num = PyArray_INT;
+        else if (size == sizeof(longlong))
+            type_num = PyArray_LONGLONG;
+        else _MY_FAIL
+                 break;
+    case 'f':
+        if (size == sizeof(float))
+            type_num = PyArray_FLOAT;
+        else if (size == sizeof(double))
+            type_num = PyArray_DOUBLE;
+        else if (size == sizeof(longdouble))
+            type_num = PyArray_LONGDOUBLE;
+        else _MY_FAIL
+                 break;
+    case 'c':
+        if (size == sizeof(float)*2)
+            type_num = PyArray_CFLOAT;
+        else if (size == sizeof(double)*2)
+            type_num = PyArray_CDOUBLE;
+        else if (size == sizeof(longdouble)*2)
+            type_num = PyArray_CLONGDOUBLE;
+        else _MY_FAIL
+                 break;
+    case 'O':
+        if (size == sizeof(PyObject *))
+            type_num = PyArray_OBJECT;
+        else _MY_FAIL
+                 break;
+    case PyArray_STRINGLTR:
+        type_num = PyArray_STRING;
+        break;
+    case PyArray_UNICODELTR:
+        type_num = PyArray_UNICODE;
+        size <<= 2;
+        break;
+    case 'V':
+        type_num = PyArray_VOID;
+        break;
+    default:
+        _MY_FAIL
+            }
 
 #undef _MY_FAIL
 
@@ -8138,13 +8137,13 @@ _array_typedescr_fromstr(char *str)
     if (descr == NULL) return NULL;
     swap = !PyArray_ISNBO(swapchar);
     if (descr->elsize == 0 || swap) {
-            /* Need to make a new PyArray_Descr */
-            PyArray_DESCR_REPLACE(descr);
-            if (descr==NULL) return NULL;
-            if (descr->elsize == 0)
-                    descr->elsize = size;
-            if (swap)
-                    descr->byteorder = swapchar;
+        /* Need to make a new PyArray_Descr */
+        PyArray_DESCR_REPLACE(descr);
+        if (descr==NULL) return NULL;
+        if (descr->elsize == 0)
+            descr->elsize = size;
+        if (swap)
+            descr->byteorder = swapchar;
     }
     return descr;
 }
@@ -8153,54 +8152,54 @@ _array_typedescr_fromstr(char *str)
 static PyObject *
 PyArray_FromStructInterface(PyObject *input)
 {
-        PyArray_Descr *thetype=NULL;
-        char buf[40];
-        PyArrayInterface *inter;
-        PyObject *attr, *r;
-        char endian = PyArray_NATBYTE;
+    PyArray_Descr *thetype=NULL;
+    char buf[40];
+    PyArrayInterface *inter;
+    PyObject *attr, *r;
+    char endian = PyArray_NATBYTE;
 
-        attr = PyObject_GetAttrString(input, "__array_struct__");
-        if (attr == NULL) {
-                PyErr_Clear();
-                return Py_NotImplemented;
-        }
-        if (!PyCObject_Check(attr)) goto fail;
-        inter = PyCObject_AsVoidPtr(attr);
-        if (inter->two != 2) goto fail;
-        if ((inter->flags & NOTSWAPPED) != NOTSWAPPED) {
-                endian = PyArray_OPPBYTE;
-                inter->flags &= ~NOTSWAPPED;
-        }
+    attr = PyObject_GetAttrString(input, "__array_struct__");
+    if (attr == NULL) {
+        PyErr_Clear();
+        return Py_NotImplemented;
+    }
+    if (!PyCObject_Check(attr)) goto fail;
+    inter = PyCObject_AsVoidPtr(attr);
+    if (inter->two != 2) goto fail;
+    if ((inter->flags & NOTSWAPPED) != NOTSWAPPED) {
+        endian = PyArray_OPPBYTE;
+        inter->flags &= ~NOTSWAPPED;
+    }
 
-        if (inter->flags & ARR_HAS_DESCR) {
-                if (PyArray_DescrConverter(inter->descr, &thetype) == PY_FAIL) {
-                        thetype = NULL;
-                        PyErr_Clear();
-                }
+    if (inter->flags & ARR_HAS_DESCR) {
+        if (PyArray_DescrConverter(inter->descr, &thetype) == PY_FAIL) {
+            thetype = NULL;
+            PyErr_Clear();
         }
+    }
 
-        if (thetype == NULL) {
-                snprintf(buf, 40, "%c%c%d", endian, inter->typekind, inter->itemsize);
-                if (!(thetype=_array_typedescr_fromstr(buf))) {
-                        Py_DECREF(attr);
-                        return NULL;
-                }
+    if (thetype == NULL) {
+        snprintf(buf, 40, "%c%c%d", endian, inter->typekind, inter->itemsize);
+        if (!(thetype=_array_typedescr_fromstr(buf))) {
+            Py_DECREF(attr);
+            return NULL;
         }
+    }
 
-        r = PyArray_NewFromDescr(&PyArray_Type, thetype,
-                                 inter->nd, inter->shape,
-                                 inter->strides, inter->data,
-                                 inter->flags, NULL);
-        Py_INCREF(input);
-        PyArray_BASE(r) = input;
-        Py_DECREF(attr);
-        PyArray_UpdateFlags((PyArrayObject *)r, UPDATE_ALL);
-        return r;
+    r = PyArray_NewFromDescr(&PyArray_Type, thetype,
+                             inter->nd, inter->shape,
+                             inter->strides, inter->data,
+                             inter->flags, NULL);
+    Py_INCREF(input);
+    PyArray_BASE(r) = input;
+    Py_DECREF(attr);
+    PyArray_UpdateFlags((PyArrayObject *)r, UPDATE_ALL);
+    return r;
 
  fail:
-        PyErr_SetString(PyExc_ValueError, "invalid __array_struct__");
-        Py_DECREF(attr);
-        return NULL;
+    PyErr_SetString(PyExc_ValueError, "invalid __array_struct__");
+    Py_DECREF(attr);
+    return NULL;
 }
 
 #define PyIntOrLong_Check(obj) (PyInt_Check(obj) || PyLong_Check(obj))
@@ -8209,198 +8208,198 @@ PyArray_FromStructInterface(PyObject *input)
 static PyObject *
 PyArray_FromInterface(PyObject *input)
 {
-        PyObject *attr=NULL, *item=NULL;
-        PyObject *tstr=NULL, *shape=NULL;
-        PyObject *inter=NULL;
-        PyObject *base=NULL;
-        PyArrayObject *ret;
-        PyArray_Descr *type=NULL;
-        char *data;
-        Py_ssize_t buffer_len;
-        int res, i, n;
-        intp dims[MAX_DIMS], strides[MAX_DIMS];
-        int dataflags = BEHAVED;
-
-        /* Get the memory from __array_data__ and __array_offset__ */
-        /* Get the shape */
-        /* Get the typestring -- ignore array_descr */
-        /* Get the strides */
-
-        inter = PyObject_GetAttrString(input, "__array_interface__");
-        if (inter == NULL) {PyErr_Clear(); return Py_NotImplemented;}
-        if (!PyDict_Check(inter)) {Py_DECREF(inter); return Py_NotImplemented;}
-
-        shape = PyDict_GetItemString(inter, "shape");
-        if (shape == NULL) {Py_DECREF(inter); return Py_NotImplemented;}
-        tstr = PyDict_GetItemString(inter, "typestr");
-        if (tstr == NULL) {Py_DECREF(inter); return Py_NotImplemented;}
-
-        attr = PyDict_GetItemString(inter, "data");
-        base = input;
-        if ((attr == NULL) || (attr==Py_None) || (!PyTuple_Check(attr))) {
-                if (attr && (attr != Py_None)) item=attr;
-                else item=input;
-                res = PyObject_AsWriteBuffer(item, (void **)&data,
-                                             &buffer_len);
-                if (res < 0) {
-                        PyErr_Clear();
-                        res = PyObject_AsReadBuffer(item, (const void **)&data,
-                                                    &buffer_len);
-                        if (res < 0) goto fail;
-                        dataflags &= ~WRITEABLE;
-                }
-                attr = PyDict_GetItemString(inter, "offset");
-                if (attr) {
-                        longlong num = PyLong_AsLongLong(attr);
-                        if (error_converting(num)) {
-                                PyErr_SetString(PyExc_TypeError,
-                                                "offset "\
-                                                "must be an integer");
-                                goto fail;
-                        }
-                        data += num;
-                }
-                base = item;
+    PyObject *attr=NULL, *item=NULL;
+    PyObject *tstr=NULL, *shape=NULL;
+    PyObject *inter=NULL;
+    PyObject *base=NULL;
+    PyArrayObject *ret;
+    PyArray_Descr *type=NULL;
+    char *data;
+    Py_ssize_t buffer_len;
+    int res, i, n;
+    intp dims[MAX_DIMS], strides[MAX_DIMS];
+    int dataflags = BEHAVED;
+
+    /* Get the memory from __array_data__ and __array_offset__ */
+    /* Get the shape */
+    /* Get the typestring -- ignore array_descr */
+    /* Get the strides */
+
+    inter = PyObject_GetAttrString(input, "__array_interface__");
+    if (inter == NULL) {PyErr_Clear(); return Py_NotImplemented;}
+    if (!PyDict_Check(inter)) {Py_DECREF(inter); return Py_NotImplemented;}
+
+    shape = PyDict_GetItemString(inter, "shape");
+    if (shape == NULL) {Py_DECREF(inter); return Py_NotImplemented;}
+    tstr = PyDict_GetItemString(inter, "typestr");
+    if (tstr == NULL) {Py_DECREF(inter); return Py_NotImplemented;}
+
+    attr = PyDict_GetItemString(inter, "data");
+    base = input;
+    if ((attr == NULL) || (attr==Py_None) || (!PyTuple_Check(attr))) {
+        if (attr && (attr != Py_None)) item=attr;
+        else item=input;
+        res = PyObject_AsWriteBuffer(item, (void **)&data,
+                                     &buffer_len);
+        if (res < 0) {
+            PyErr_Clear();
+            res = PyObject_AsReadBuffer(item, (const void **)&data,
+                                        &buffer_len);
+            if (res < 0) goto fail;
+            dataflags &= ~WRITEABLE;
+        }
+        attr = PyDict_GetItemString(inter, "offset");
+        if (attr) {
+            longlong num = PyLong_AsLongLong(attr);
+            if (error_converting(num)) {
+                PyErr_SetString(PyExc_TypeError,
+                                "offset "\
+                                "must be an integer");
+                goto fail;
+            }
+            data += num;
+        }
+        base = item;
+    }
+    else {
+        PyObject *dataptr;
+        if (PyTuple_GET_SIZE(attr) != 2) {
+            PyErr_SetString(PyExc_TypeError,
+                            "data must return "     \
+                            "a 2-tuple with (data pointer "\
+                            "integer, read-only flag)");
+            goto fail;
+        }
+        dataptr = PyTuple_GET_ITEM(attr, 0);
+        if (PyString_Check(dataptr)) {
+            res = sscanf(PyString_AsString(dataptr),
+                         "%p", (void **)&data);
+            if (res < 1) {
+                PyErr_SetString(PyExc_TypeError,
+                                "data string cannot be " \
+                                "converted");
+                goto fail;
+            }
+        }
+        else if (PyIntOrLong_Check(dataptr)) {
+            data = PyLong_AsVoidPtr(dataptr);
         }
         else {
-                PyObject *dataptr;
-                if (PyTuple_GET_SIZE(attr) != 2) {
-                        PyErr_SetString(PyExc_TypeError,
-                                        "data must return "     \
-                                        "a 2-tuple with (data pointer "\
-                                        "integer, read-only flag)");
-                        goto fail;
-                }
-                dataptr = PyTuple_GET_ITEM(attr, 0);
-                if (PyString_Check(dataptr)) {
-                        res = sscanf(PyString_AsString(dataptr),
-                                     "%p", (void **)&data);
-                        if (res < 1) {
-                                PyErr_SetString(PyExc_TypeError,
-                                                "data string cannot be " \
-                                                "converted");
-                                goto fail;
-                        }
-                }
-                else if (PyIntOrLong_Check(dataptr)) {
-                        data = PyLong_AsVoidPtr(dataptr);
-                }
-                else {
-                        PyErr_SetString(PyExc_TypeError, "first element " \
-                                        "of data tuple must be integer" \
-                                        " or string.");
-                        goto fail;
-                }
-                if (PyObject_IsTrue(PyTuple_GET_ITEM(attr,1))) {
-                        dataflags &= ~WRITEABLE;
-                }
+            PyErr_SetString(PyExc_TypeError, "first element " \
+                            "of data tuple must be integer" \
+                            " or string.");
+            goto fail;
         }
-        attr = tstr;
-        if (!PyString_Check(attr)) {
-                PyErr_SetString(PyExc_TypeError, "typestr must be a string");
-                goto fail;
+        if (PyObject_IsTrue(PyTuple_GET_ITEM(attr,1))) {
+            dataflags &= ~WRITEABLE;
         }
-        type = _array_typedescr_fromstr(PyString_AS_STRING(attr));
-        if (type==NULL) goto fail;
-        attr = shape;
+    }
+    attr = tstr;
+    if (!PyString_Check(attr)) {
+        PyErr_SetString(PyExc_TypeError, "typestr must be a string");
+        goto fail;
+    }
+    type = _array_typedescr_fromstr(PyString_AS_STRING(attr));
+    if (type==NULL) goto fail;
+    attr = shape;
+    if (!PyTuple_Check(attr)) {
+        PyErr_SetString(PyExc_TypeError, "shape must be a tuple");
+        Py_DECREF(type);
+        goto fail;
+    }
+    n = PyTuple_GET_SIZE(attr);
+    for (i=0; i<n; i++) {
+        item = PyTuple_GET_ITEM(attr, i);
+        dims[i] = PyArray_PyIntAsIntp(item);
+        if (error_converting(dims[i])) break;
+    }
+
+    ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, type,
+                                                n, dims,
+                                                NULL, data,
+                                                dataflags, NULL);
+    if (ret == NULL) return NULL;
+    Py_INCREF(base);
+    ret->base = base;
+
+    attr = PyDict_GetItemString(inter, "strides");
+    if (attr != NULL && attr != Py_None) {
         if (!PyTuple_Check(attr)) {
-                PyErr_SetString(PyExc_TypeError, "shape must be a tuple");
-                Py_DECREF(type);
-                goto fail;
+            PyErr_SetString(PyExc_TypeError,
+                            "strides must be a tuple");
+            Py_DECREF(ret);
+            return NULL;
         }
-        n = PyTuple_GET_SIZE(attr);
-        for (i=0; i<n; i++) {
-                item = PyTuple_GET_ITEM(attr, i);
-                dims[i] = PyArray_PyIntAsIntp(item);
-                if (error_converting(dims[i])) break;
+        if (n != PyTuple_GET_SIZE(attr)) {
+            PyErr_SetString(PyExc_ValueError,
+                            "mismatch in length of "\
+                            "strides and shape");
+            Py_DECREF(ret);
+            return NULL;
         }
-
-        ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, type,
-                                                    n, dims,
-                                                    NULL, data,
-                                                    dataflags, NULL);
-        if (ret == NULL) return NULL;
-        Py_INCREF(base);
-        ret->base = base;
-
-        attr = PyDict_GetItemString(inter, "strides");
-        if (attr != NULL && attr != Py_None) {
-                if (!PyTuple_Check(attr)) {
-                        PyErr_SetString(PyExc_TypeError,
-                                        "strides must be a tuple");
-                        Py_DECREF(ret);
-                        return NULL;
-                }
-                if (n != PyTuple_GET_SIZE(attr)) {
-                        PyErr_SetString(PyExc_ValueError,
-                                        "mismatch in length of "\
-                                        "strides and shape");
-                        Py_DECREF(ret);
-                        return NULL;
-                }
-                for (i=0; i<n; i++) {
-                        item = PyTuple_GET_ITEM(attr, i);
-                        strides[i] = PyArray_PyIntAsIntp(item);
-                        if (error_converting(strides[i])) break;
-                }
-                if (PyErr_Occurred()) PyErr_Clear();
-                memcpy(ret->strides, strides, n*sizeof(intp));
+        for (i=0; i<n; i++) {
+            item = PyTuple_GET_ITEM(attr, i);
+            strides[i] = PyArray_PyIntAsIntp(item);
+            if (error_converting(strides[i])) break;
         }
-        else PyErr_Clear();
-        PyArray_UpdateFlags(ret, UPDATE_ALL);
-        Py_DECREF(inter);
-        return (PyObject *)ret;
+        if (PyErr_Occurred()) PyErr_Clear();
+        memcpy(ret->strides, strides, n*sizeof(intp));
+    }
+    else PyErr_Clear();
+    PyArray_UpdateFlags(ret, UPDATE_ALL);
+    Py_DECREF(inter);
+    return (PyObject *)ret;
 
  fail:
-        Py_XDECREF(inter);
-        return NULL;
+    Py_XDECREF(inter);
+    return NULL;
 }
 
 /*OBJECT_API*/
 static PyObject *
 PyArray_FromArrayAttr(PyObject *op, PyArray_Descr *typecode, PyObject *context)
 {
-        PyObject *new;
-        PyObject *array_meth;
+    PyObject *new;
+    PyObject *array_meth;
 
-        array_meth = PyObject_GetAttrString(op, "__array__");
-        if (array_meth == NULL) {PyErr_Clear(); return Py_NotImplemented;}
-        if (context == NULL) {
-                if (typecode == NULL) new = PyObject_CallFunction(array_meth,
-                                                                  NULL);
-                else new = PyObject_CallFunction(array_meth, "O", typecode);
+    array_meth = PyObject_GetAttrString(op, "__array__");
+    if (array_meth == NULL) {PyErr_Clear(); return Py_NotImplemented;}
+    if (context == NULL) {
+        if (typecode == NULL) new = PyObject_CallFunction(array_meth,
+                                                          NULL);
+        else new = PyObject_CallFunction(array_meth, "O", typecode);
+    }
+    else {
+        if (typecode == NULL) {
+            new = PyObject_CallFunction(array_meth, "OO", Py_None,
+                                        context);
+            if (new == NULL && \
+                PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Clear();
+                new = PyObject_CallFunction(array_meth, "");
+            }
         }
         else {
-                if (typecode == NULL) {
-                        new = PyObject_CallFunction(array_meth, "OO", Py_None,
-                                                    context);
-                        if (new == NULL && \
-                            PyErr_ExceptionMatches(PyExc_TypeError)) {
-                                PyErr_Clear();
-                                new = PyObject_CallFunction(array_meth, "");
-                        }
-                }
-                else {
-                        new = PyObject_CallFunction(array_meth, "OO",
-                                                    typecode, context);
-                        if (new == NULL && \
-                            PyErr_ExceptionMatches(PyExc_TypeError)) {
-                                PyErr_Clear();
-                                new = PyObject_CallFunction(array_meth, "O",
-                                                            typecode);
-                        }
-                }
-        }
-        Py_DECREF(array_meth);
-        if (new == NULL) return NULL;
-        if (!PyArray_Check(new)) {
-                PyErr_SetString(PyExc_ValueError,
-                                "object __array__ method not "  \
-                                "producing an array");
-                Py_DECREF(new);
-                return NULL;
+            new = PyObject_CallFunction(array_meth, "OO",
+                                        typecode, context);
+            if (new == NULL && \
+                PyErr_ExceptionMatches(PyExc_TypeError)) {
+                PyErr_Clear();
+                new = PyObject_CallFunction(array_meth, "O",
+                                            typecode);
+            }
         }
-        return new;
+    }
+    Py_DECREF(array_meth);
+    if (new == NULL) return NULL;
+    if (!PyArray_Check(new)) {
+        PyErr_SetString(PyExc_ValueError,
+                        "object __array__ method not "  \
+                        "producing an array");
+        Py_DECREF(new);
+        return NULL;
+    }
+    return new;
 }
 
 /* Does not check for ENSURECOPY and NOTSWAPPED in flags */
@@ -8410,108 +8409,108 @@ static PyObject *
 PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth,
                 int max_depth, int flags, PyObject *context)
 {
-        /* This is the main code to make a NumPy array from a Python
-           Object.  It is called from lot's of different places which
-           is why there are so many checks.  The comments try to
-           explain some of the checks. */
-
-        PyObject *r=NULL;
-        int seq = FALSE;
-
-        /* Is input object already an array? */
-        /*  This is where the flags are used */
-        if (PyArray_Check(op))
-                r = PyArray_FromArray((PyArrayObject *)op, newtype, flags);
-        else if (PyArray_IsScalar(op, Generic)) {
-                if (flags & UPDATEIFCOPY) goto err;
-                r = PyArray_FromScalar(op, newtype);
-        } else if (newtype == NULL &&
-                   (newtype = _array_find_python_scalar_type(op))) {
-            if (flags & UPDATEIFCOPY) goto err;
-            r = Array_FromPyScalar(op, newtype);
+    /* This is the main code to make a NumPy array from a Python
+       Object.  It is called from lot's of different places which
+       is why there are so many checks.  The comments try to
+       explain some of the checks. */
+
+    PyObject *r=NULL;
+    int seq = FALSE;
+
+    /* Is input object already an array? */
+    /*  This is where the flags are used */
+    if (PyArray_Check(op))
+        r = PyArray_FromArray((PyArrayObject *)op, newtype, flags);
+    else if (PyArray_IsScalar(op, Generic)) {
+        if (flags & UPDATEIFCOPY) goto err;
+        r = PyArray_FromScalar(op, newtype);
+    } else if (newtype == NULL &&
+               (newtype = _array_find_python_scalar_type(op))) {
+        if (flags & UPDATEIFCOPY) goto err;
+        r = Array_FromPyScalar(op, newtype);
+    }
+    else if (PyArray_HasArrayInterfaceType(op, newtype, context, r)) {
+        PyObject *new;
+        if (r == NULL) {Py_XDECREF(newtype); return NULL;}
+        if (newtype != NULL || flags != 0) {
+            new = PyArray_FromArray((PyArrayObject *)r, newtype,
+                                    flags);
+            Py_DECREF(r);
+            r = new;
         }
-        else if (PyArray_HasArrayInterfaceType(op, newtype, context, r)) {
-                PyObject *new;
-                if (r == NULL) {Py_XDECREF(newtype); return NULL;}
-                if (newtype != NULL || flags != 0) {
-                        new = PyArray_FromArray((PyArrayObject *)r, newtype,
-                                                flags);
-                        Py_DECREF(r);
-                        r = new;
-                }
+    }
+    else {
+        int isobject=0;
+        if (flags & UPDATEIFCOPY) goto err;
+        if (newtype == NULL) {
+            newtype = _array_find_type(op, NULL, MAX_DIMS);
         }
-        else {
-                int isobject=0;
-                if (flags & UPDATEIFCOPY) goto err;
-                if (newtype == NULL) {
-                        newtype = _array_find_type(op, NULL, MAX_DIMS);
-                }
-                else if (newtype->type_num == PyArray_OBJECT) {
-                        isobject = 1;
-                }
-                if (PySequence_Check(op)) {
-                        PyObject *thiserr=NULL;
-                        /* necessary but not sufficient */
-                        Py_INCREF(newtype);
-                        r = Array_FromSequence(op, newtype, flags & FORTRAN,
-                                               min_depth, max_depth);
-                        if (r == NULL && (thiserr=PyErr_Occurred())) {
-                                if (PyErr_GivenExceptionMatches(thiserr, 
-                                                                PyExc_MemoryError))
-                                        return NULL;
-                                /* If object was explicitly requested, 
-                                   then try nested list object array creation
-                                */
-                                PyErr_Clear();
-                                if (isobject) {
-                                        Py_INCREF(newtype);
-                                        r = ObjectArray_FromNestedList  \
-                                                (op, newtype, flags & FORTRAN);
-                                        seq = TRUE;
-                                        Py_DECREF(newtype);
-                                }
-                        }
-                        else {
-                                seq = TRUE;
-                                Py_DECREF(newtype);
-                        }
+        else if (newtype->type_num == PyArray_OBJECT) {
+            isobject = 1;
+        }
+        if (PySequence_Check(op)) {
+            PyObject *thiserr=NULL;
+            /* necessary but not sufficient */
+            Py_INCREF(newtype);
+            r = Array_FromSequence(op, newtype, flags & FORTRAN,
+                                   min_depth, max_depth);
+            if (r == NULL && (thiserr=PyErr_Occurred())) {
+                if (PyErr_GivenExceptionMatches(thiserr,
+                                                PyExc_MemoryError))
+                    return NULL;
+                /* If object was explicitly requested,
+                   then try nested list object array creation
+                */
+                PyErr_Clear();
+                if (isobject) {
+                    Py_INCREF(newtype);
+                    r = ObjectArray_FromNestedList  \
+                        (op, newtype, flags & FORTRAN);
+                    seq = TRUE;
+                    Py_DECREF(newtype);
                 }
-                if (!seq)
-                        r = Array_FromPyScalar(op, newtype);
+            }
+            else {
+                seq = TRUE;
+                Py_DECREF(newtype);
+            }
         }
+        if (!seq)
+            r = Array_FromPyScalar(op, newtype);
+    }
 
-        /* If we didn't succeed return NULL */
-        if (r == NULL) return NULL;
+    /* If we didn't succeed return NULL */
+    if (r == NULL) return NULL;
 
-        /* Be sure we succeed here */
+    /* Be sure we succeed here */
 
-        if(!PyArray_Check(r)) {
-                PyErr_SetString(PyExc_RuntimeError,
-                                "internal error: PyArray_FromAny "\
-                                "not producing an array");
-                Py_DECREF(r);
-                return NULL;
-        }
+    if(!PyArray_Check(r)) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "internal error: PyArray_FromAny "\
+                        "not producing an array");
+        Py_DECREF(r);
+        return NULL;
+    }
 
-        if (min_depth != 0 && ((PyArrayObject *)r)->nd < min_depth) {
-                PyErr_SetString(PyExc_ValueError,
-                                "object of too small depth for desired array");
-                Py_DECREF(r);
-                return NULL;
-        }
-        if (max_depth != 0 && ((PyArrayObject *)r)->nd > max_depth) {
-                PyErr_SetString(PyExc_ValueError,
-                                "object too deep for desired array");
-                Py_DECREF(r);
-                return NULL;
-        }
-        return r;
+    if (min_depth != 0 && ((PyArrayObject *)r)->nd < min_depth) {
+        PyErr_SetString(PyExc_ValueError,
+                        "object of too small depth for desired array");
+        Py_DECREF(r);
+        return NULL;
+    }
+    if (max_depth != 0 && ((PyArrayObject *)r)->nd > max_depth) {
+        PyErr_SetString(PyExc_ValueError,
+                        "object too deep for desired array");
+        Py_DECREF(r);
+        return NULL;
+    }
+    return r;
 
  err:
-        Py_XDECREF(newtype);
-        PyErr_SetString(PyExc_TypeError,
-                        "UPDATEIFCOPY used for non-array input.");
-        return NULL;
+    Py_XDECREF(newtype);
+    PyErr_SetString(PyExc_TypeError,
+                    "UPDATEIFCOPY used for non-array input.");
+    return NULL;
 }
 
 /* new reference -- accepts NULL for mintype*/
@@ -8519,41 +8518,41 @@ PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth,
 static PyArray_Descr *
 PyArray_DescrFromObject(PyObject *op, PyArray_Descr *mintype)
 {
-        return _array_find_type(op, mintype, MAX_DIMS);
+    return _array_find_type(op, mintype, MAX_DIMS);
 }
 
 /*OBJECT_API
- Return the typecode of the array a Python object would be converted
- to
+  Return the typecode of the array a Python object would be converted
+  to
 */
 static int
 PyArray_ObjectType(PyObject *op, int minimum_type)
 {
-        PyArray_Descr *intype;
-        PyArray_Descr *outtype;
-        int ret;
+    PyArray_Descr *intype;
+    PyArray_Descr *outtype;
+    int ret;
 
-        intype = PyArray_DescrFromType(minimum_type);
-        if (intype == NULL) PyErr_Clear();
-        outtype = _array_find_type(op, intype, MAX_DIMS);
-        ret = outtype->type_num;
-        Py_DECREF(outtype);
-        Py_XDECREF(intype);
-        return ret;
+    intype = PyArray_DescrFromType(minimum_type);
+    if (intype == NULL) PyErr_Clear();
+    outtype = _array_find_type(op, intype, MAX_DIMS);
+    ret = outtype->type_num;
+    Py_DECREF(outtype);
+    Py_XDECREF(intype);
+    return ret;
 }
 
 
 /* flags is any of
-  CONTIGUOUS,
-  FORTRAN,
-  ALIGNED,
-  WRITEABLE,
-  NOTSWAPPED,
-  ENSURECOPY,
-  UPDATEIFCOPY,
-  FORCECAST,
-  ENSUREARRAY,
-  ELEMENTSTRIDES
+   CONTIGUOUS,
+   FORTRAN,
+   ALIGNED,
+   WRITEABLE,
+   NOTSWAPPED,
+   ENSURECOPY,
+   UPDATEIFCOPY,
+   FORCECAST,
+   ENSUREARRAY,
+   ELEMENTSTRIDES
 
    or'd (|) together
 
@@ -8590,35 +8589,35 @@ static PyObject *
 PyArray_CheckFromAny(PyObject *op, PyArray_Descr *descr, int min_depth,
                      int max_depth, int requires, PyObject *context)
 {
-        PyObject *obj;
-        if (requires & NOTSWAPPED) {
-                if (!descr && PyArray_Check(op) && \
-                    !PyArray_ISNBO(PyArray_DESCR(op)->byteorder)) {
-                        descr = PyArray_DescrNew(PyArray_DESCR(op));
-                }
-                else if (descr && !PyArray_ISNBO(descr->byteorder)) {
-                        PyArray_DESCR_REPLACE(descr);
-                }
-                if (descr) {
-                        descr->byteorder = PyArray_NATIVE;
-                }
+    PyObject *obj;
+    if (requires & NOTSWAPPED) {
+        if (!descr && PyArray_Check(op) && \
+            !PyArray_ISNBO(PyArray_DESCR(op)->byteorder)) {
+            descr = PyArray_DescrNew(PyArray_DESCR(op));
         }
-
-        obj = PyArray_FromAny(op, descr, min_depth, max_depth,
-                              requires, context);
-        if (obj == NULL) return NULL;
-        if ((requires & ELEMENTSTRIDES) &&
-            !PyArray_ElementStrides(obj)) {
-                PyObject *new;
-                new = PyArray_NewCopy((PyArrayObject *)obj, PyArray_ANYORDER);
-                Py_DECREF(obj);
-                obj = new;
+        else if (descr && !PyArray_ISNBO(descr->byteorder)) {
+            PyArray_DESCR_REPLACE(descr);
         }
-        return obj;
+        if (descr) {
+            descr->byteorder = PyArray_NATIVE;
+        }
+    }
+
+    obj = PyArray_FromAny(op, descr, min_depth, max_depth,
+                          requires, context);
+    if (obj == NULL) return NULL;
+    if ((requires & ELEMENTSTRIDES) &&
+        !PyArray_ElementStrides(obj)) {
+        PyObject *new;
+        new = PyArray_NewCopy((PyArrayObject *)obj, PyArray_ANYORDER);
+        Py_DECREF(obj);
+        obj = new;
+    }
+    return obj;
 }
 
 /* This is a quick wrapper around PyArray_FromAny(op, NULL, 0, 0,
-    ENSUREARRAY) */
+   ENSUREARRAY) */
 /*  that special cases Arrays and PyArray_Scalars up front */
 /*  It *steals a reference* to the object */
 /*  It also guarantees that the result is PyArray_Type */
@@ -8630,139 +8629,139 @@ PyArray_CheckFromAny(PyObject *op, PyArray_Descr *descr, int min_depth,
 static PyObject *
 PyArray_EnsureArray(PyObject *op)
 {
-        PyObject *new;
+    PyObject *new;
 
-        if (op == NULL) return NULL;
+    if (op == NULL) return NULL;
 
-        if (PyArray_CheckExact(op)) return op;
+    if (PyArray_CheckExact(op)) return op;
 
-        if (PyArray_Check(op)) {
-                new = PyArray_View((PyArrayObject *)op, NULL, &PyArray_Type);
-                Py_DECREF(op);
-                return new;
-        }
-        if (PyArray_IsScalar(op, Generic)) {
-                new = PyArray_FromScalar(op, NULL);
-                Py_DECREF(op);
-                return new;
-        }
-        new = PyArray_FromAny(op, NULL, 0, 0, ENSUREARRAY, NULL);
+    if (PyArray_Check(op)) {
+        new = PyArray_View((PyArrayObject *)op, NULL, &PyArray_Type);
         Py_DECREF(op);
         return new;
+    }
+    if (PyArray_IsScalar(op, Generic)) {
+        new = PyArray_FromScalar(op, NULL);
+        Py_DECREF(op);
+        return new;
+    }
+    new = PyArray_FromAny(op, NULL, 0, 0, ENSUREARRAY, NULL);
+    Py_DECREF(op);
+    return new;
 }
 
 /*OBJECT_API*/
 static PyObject *
 PyArray_EnsureAnyArray(PyObject *op)
 {
-        if (op && PyArray_Check(op)) return op;
-        return PyArray_EnsureArray(op);
+    if (op && PyArray_Check(op)) return op;
+    return PyArray_EnsureArray(op);
 }
 
 /*OBJECT_API
- Check the type coercion rules.
+  Check the type coercion rules.
 */
 static int
 PyArray_CanCastSafely(int fromtype, int totype)
 {
-        PyArray_Descr *from, *to;
-        register int felsize, telsize;
-
-        if (fromtype == totype) return 1;
-        if (fromtype == PyArray_BOOL) return 1;
-        if (totype == PyArray_BOOL) return 0;
-        if (totype == PyArray_OBJECT || totype == PyArray_VOID) return 1;
-        if (fromtype == PyArray_OBJECT || fromtype == PyArray_VOID) return 0;
-
-        from = PyArray_DescrFromType(fromtype);
-        /* cancastto is a PyArray_NOTYPE terminated C-int-array of types that
-           the data-type can be cast to safely.
-        */
-        if (from->f->cancastto) {
-                int *curtype;
-                curtype = from->f->cancastto;
-                while (*curtype != PyArray_NOTYPE) {
-                        if (*curtype++ == totype) return 1;
-                }
+    PyArray_Descr *from, *to;
+    register int felsize, telsize;
+
+    if (fromtype == totype) return 1;
+    if (fromtype == PyArray_BOOL) return 1;
+    if (totype == PyArray_BOOL) return 0;
+    if (totype == PyArray_OBJECT || totype == PyArray_VOID) return 1;
+    if (fromtype == PyArray_OBJECT || fromtype == PyArray_VOID) return 0;
+
+    from = PyArray_DescrFromType(fromtype);
+    /* cancastto is a PyArray_NOTYPE terminated C-int-array of types that
+       the data-type can be cast to safely.
+    */
+    if (from->f->cancastto) {
+        int *curtype;
+        curtype = from->f->cancastto;
+        while (*curtype != PyArray_NOTYPE) {
+            if (*curtype++ == totype) return 1;
         }
-        if (PyTypeNum_ISUSERDEF(totype)) return 0;
-
-        to = PyArray_DescrFromType(totype);
-        telsize = to->elsize;
-        felsize = from->elsize;
-        Py_DECREF(from);
-        Py_DECREF(to);
-
-        switch(fromtype) {
-        case PyArray_BYTE:
-        case PyArray_SHORT:
-        case PyArray_INT:
-        case PyArray_LONG:
-        case PyArray_LONGLONG:
-                if (PyTypeNum_ISINTEGER(totype)) {
-                        if (PyTypeNum_ISUNSIGNED(totype)) {
-                                return 0;
-                        }
-                        else {
-                                return (telsize >= felsize);
-                        }
-                }
-                else if (PyTypeNum_ISFLOAT(totype)) {
-                        if (felsize < 8)
-                                return (telsize > felsize);
-                        else
-                                return (telsize >= felsize);
-                }
-                else if (PyTypeNum_ISCOMPLEX(totype)) {
-                        if (felsize < 8)
-                                return ((telsize >> 1) > felsize);
-                        else
-                                return ((telsize >> 1) >= felsize);
-                }
-                else return totype > fromtype;
-        case PyArray_UBYTE:
-        case PyArray_USHORT:
-        case PyArray_UINT:
-        case PyArray_ULONG:
-        case PyArray_ULONGLONG:
-                if (PyTypeNum_ISINTEGER(totype)) {
-                        if (PyTypeNum_ISSIGNED(totype)) {
-                                return (telsize > felsize);
-                        }
-                        else {
-                                return (telsize >= felsize);
-                        }
-                }
-                else if (PyTypeNum_ISFLOAT(totype)) {
-                        if (felsize < 8)
-                                return (telsize > felsize);
-                        else
-                                return (telsize >= felsize);
-                }
-                else if (PyTypeNum_ISCOMPLEX(totype)) {
-                        if (felsize < 8)
-                                return ((telsize >> 1) > felsize);
-                        else
-                                return ((telsize >> 1) >= felsize);
-                }
-                else return totype > fromtype;
-        case PyArray_FLOAT:
-        case PyArray_DOUBLE:
-        case PyArray_LONGDOUBLE:
-                if (PyTypeNum_ISCOMPLEX(totype))
-                        return ((telsize >> 1) >= felsize);
-                else
-                        return (totype > fromtype);
-        case PyArray_CFLOAT:
-        case PyArray_CDOUBLE:
-        case PyArray_CLONGDOUBLE:
-                return (totype > fromtype);
-        case PyArray_STRING:
-        case PyArray_UNICODE:
-                return (totype > fromtype);
-        default:
+    }
+    if (PyTypeNum_ISUSERDEF(totype)) return 0;
+
+    to = PyArray_DescrFromType(totype);
+    telsize = to->elsize;
+    felsize = from->elsize;
+    Py_DECREF(from);
+    Py_DECREF(to);
+
+    switch(fromtype) {
+    case PyArray_BYTE:
+    case PyArray_SHORT:
+    case PyArray_INT:
+    case PyArray_LONG:
+    case PyArray_LONGLONG:
+        if (PyTypeNum_ISINTEGER(totype)) {
+            if (PyTypeNum_ISUNSIGNED(totype)) {
                 return 0;
+            }
+            else {
+                return (telsize >= felsize);
+            }
+        }
+        else if (PyTypeNum_ISFLOAT(totype)) {
+            if (felsize < 8)
+                return (telsize > felsize);
+            else
+                return (telsize >= felsize);
+        }
+        else if (PyTypeNum_ISCOMPLEX(totype)) {
+            if (felsize < 8)
+                return ((telsize >> 1) > felsize);
+            else
+                return ((telsize >> 1) >= felsize);
+        }
+        else return totype > fromtype;
+    case PyArray_UBYTE:
+    case PyArray_USHORT:
+    case PyArray_UINT:
+    case PyArray_ULONG:
+    case PyArray_ULONGLONG:
+        if (PyTypeNum_ISINTEGER(totype)) {
+            if (PyTypeNum_ISSIGNED(totype)) {
+                return (telsize > felsize);
+            }
+            else {
+                return (telsize >= felsize);
+            }
         }
+        else if (PyTypeNum_ISFLOAT(totype)) {
+            if (felsize < 8)
+                return (telsize > felsize);
+            else
+                return (telsize >= felsize);
+        }
+        else if (PyTypeNum_ISCOMPLEX(totype)) {
+            if (felsize < 8)
+                return ((telsize >> 1) > felsize);
+            else
+                return ((telsize >> 1) >= felsize);
+        }
+        else return totype > fromtype;
+    case PyArray_FLOAT:
+    case PyArray_DOUBLE:
+    case PyArray_LONGDOUBLE:
+        if (PyTypeNum_ISCOMPLEX(totype))
+            return ((telsize >> 1) >= felsize);
+        else
+            return (totype > fromtype);
+    case PyArray_CFLOAT:
+    case PyArray_CDOUBLE:
+    case PyArray_CLONGDOUBLE:
+        return (totype > fromtype);
+    case PyArray_STRING:
+    case PyArray_UNICODE:
+        return (totype > fromtype);
+    default:
+        return 0;
+    }
 }
 
 /* leaves reference count alone --- cannot be NULL*/
@@ -8770,48 +8769,48 @@ PyArray_CanCastSafely(int fromtype, int totype)
 static Bool
 PyArray_CanCastTo(PyArray_Descr *from, PyArray_Descr *to)
 {
-        int fromtype=from->type_num;
-        int totype=to->type_num;
-        Bool ret;
-
-        ret = (Bool) PyArray_CanCastSafely(fromtype, totype);
-        if (ret) { /* Check String and Unicode more closely */
-                if (fromtype == PyArray_STRING) {
-                        if (totype == PyArray_STRING) {
-                                ret = (from->elsize <= to->elsize);
-                        }
-                        else if (totype == PyArray_UNICODE) {
-                                ret = (from->elsize << 2 \
-                                       <= to->elsize);
-                        }
-                }
-                else if (fromtype == PyArray_UNICODE) {
-                        if (totype == PyArray_UNICODE) {
-                                ret = (from->elsize <= to->elsize);
-                        }
-                }
-                /* TODO: If totype is STRING or unicode
-                    see if the length is long enough to hold the
-                    stringified value of the object.
-                */
+    int fromtype=from->type_num;
+    int totype=to->type_num;
+    Bool ret;
+
+    ret = (Bool) PyArray_CanCastSafely(fromtype, totype);
+    if (ret) { /* Check String and Unicode more closely */
+        if (fromtype == PyArray_STRING) {
+            if (totype == PyArray_STRING) {
+                ret = (from->elsize <= to->elsize);
+            }
+            else if (totype == PyArray_UNICODE) {
+                ret = (from->elsize << 2 \
+                       <= to->elsize);
+            }
         }
-        return ret;
+        else if (fromtype == PyArray_UNICODE) {
+            if (totype == PyArray_UNICODE) {
+                ret = (from->elsize <= to->elsize);
+            }
+        }
+        /* TODO: If totype is STRING or unicode
+           see if the length is long enough to hold the
+           stringified value of the object.
+        */
+    }
+    return ret;
 }
 
 /*OBJECT_API
   See if array scalars can be cast.
- */
+*/
 static Bool
 PyArray_CanCastScalar(PyTypeObject *from, PyTypeObject *to)
 {
-        int fromtype;
-        int totype;
+    int fromtype;
+    int totype;
 
-        fromtype = _typenum_fromtypeobj((PyObject *)from, 0);
-        totype = _typenum_fromtypeobj((PyObject *)to, 0);
-        if (fromtype == PyArray_NOTYPE || totype == PyArray_NOTYPE)
-                return FALSE;
-        return (Bool) PyArray_CanCastSafely(fromtype, totype);
+    fromtype = _typenum_fromtypeobj((PyObject *)from, 0);
+    totype = _typenum_fromtypeobj((PyObject *)to, 0);
+    if (fromtype == PyArray_NOTYPE || totype == PyArray_NOTYPE)
+        return FALSE;
+    return (Bool) PyArray_CanCastSafely(fromtype, totype);
 }
 
 
@@ -8820,110 +8819,110 @@ PyArray_CanCastScalar(PyTypeObject *from, PyTypeObject *to)
 /*         and Python's array iterator                                   ***/
 
 /*OBJECT_API
- Get Iterator.
+  Get Iterator.
 */
 static PyObject *
 PyArray_IterNew(PyObject *obj)
 {
-        PyArrayIterObject *it;
-        int i, nd;
-        PyArrayObject *ao = (PyArrayObject *)obj;
+    PyArrayIterObject *it;
+    int i, nd;
+    PyArrayObject *ao = (PyArrayObject *)obj;
 
-        if (!PyArray_Check(ao)) {
-                PyErr_BadInternalCall();
-                return NULL;
-        }
+    if (!PyArray_Check(ao)) {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
 
-        it = (PyArrayIterObject *)_pya_malloc(sizeof(PyArrayIterObject));
-        PyObject_Init((PyObject *)it, &PyArrayIter_Type);
-        /* it = PyObject_New(PyArrayIterObject, &PyArrayIter_Type);*/
-        if (it == NULL)
-                return NULL;
+    it = (PyArrayIterObject *)_pya_malloc(sizeof(PyArrayIterObject));
+    PyObject_Init((PyObject *)it, &PyArrayIter_Type);
+    /* it = PyObject_New(PyArrayIterObject, &PyArrayIter_Type);*/
+    if (it == NULL)
+        return NULL;
 
-        nd = ao->nd;
-        PyArray_UpdateFlags(ao, CONTIGUOUS);
-        if PyArray_ISCONTIGUOUS(ao) it->contiguous = 1;
-        else it->contiguous = 0;
-        Py_INCREF(ao);
-        it->ao = ao;
-        it->size = PyArray_SIZE(ao);
-        it->nd_m1 = nd - 1;
-        it->factors[nd-1] = 1;
-        for (i=0; i < nd; i++) {
-                it->dims_m1[i] = ao->dimensions[i] - 1;
-                it->strides[i] = ao->strides[i];
-                it->backstrides[i] = it->strides[i] *   \
-                        it->dims_m1[i];
-                if (i > 0)
-                        it->factors[nd-i-1] = it->factors[nd-i] *       \
-                                ao->dimensions[nd-i];
-        }
-        PyArray_ITER_RESET(it);
+    nd = ao->nd;
+    PyArray_UpdateFlags(ao, CONTIGUOUS);
+    if PyArray_ISCONTIGUOUS(ao) it->contiguous = 1;
+    else it->contiguous = 0;
+    Py_INCREF(ao);
+    it->ao = ao;
+    it->size = PyArray_SIZE(ao);
+    it->nd_m1 = nd - 1;
+    it->factors[nd-1] = 1;
+    for (i=0; i < nd; i++) {
+        it->dims_m1[i] = ao->dimensions[i] - 1;
+        it->strides[i] = ao->strides[i];
+        it->backstrides[i] = it->strides[i] *   \
+            it->dims_m1[i];
+        if (i > 0)
+            it->factors[nd-i-1] = it->factors[nd-i] *       \
+                ao->dimensions[nd-i];
+    }
+    PyArray_ITER_RESET(it);
 
-        return (PyObject *)it;
+    return (PyObject *)it;
 }
 
 /*MULTIARRAY_API
   Get Iterator broadcast to a particular shape
- */
+*/
 static PyObject *
 PyArray_BroadcastToShape(PyObject *obj, intp *dims, int nd)
 {
-        PyArrayIterObject *it;
-        int i, diff, j, compat, k;
-        PyArrayObject *ao = (PyArrayObject *)obj;
-
-        if (ao->nd > nd) goto err;
-        compat = 1;
-        diff = j = nd - ao->nd;
-        for (i=0; i<ao->nd; i++, j++) {
-                if (ao->dimensions[i] == 1) continue;
-                if (ao->dimensions[i] != dims[j]) {
-                        compat = 0;
-                        break;
-                }
+    PyArrayIterObject *it;
+    int i, diff, j, compat, k;
+    PyArrayObject *ao = (PyArrayObject *)obj;
+
+    if (ao->nd > nd) goto err;
+    compat = 1;
+    diff = j = nd - ao->nd;
+    for (i=0; i<ao->nd; i++, j++) {
+        if (ao->dimensions[i] == 1) continue;
+        if (ao->dimensions[i] != dims[j]) {
+            compat = 0;
+            break;
         }
-        if (!compat) goto err;
+    }
+    if (!compat) goto err;
 
-        it = (PyArrayIterObject *)_pya_malloc(sizeof(PyArrayIterObject));
-        PyObject_Init((PyObject *)it, &PyArrayIter_Type);
+    it = (PyArrayIterObject *)_pya_malloc(sizeof(PyArrayIterObject));
+    PyObject_Init((PyObject *)it, &PyArrayIter_Type);
 
-        if (it == NULL)
-                return NULL;
+    if (it == NULL)
+        return NULL;
 
-        PyArray_UpdateFlags(ao, CONTIGUOUS);
-        if PyArray_ISCONTIGUOUS(ao) it->contiguous = 1;
-        else it->contiguous = 0;
-        Py_INCREF(ao);
-        it->ao = ao;
-        it->size = PyArray_MultiplyList(dims, nd);
-        it->nd_m1 = nd - 1;
-        it->factors[nd-1] = 1;
-        for (i=0; i < nd; i++) {
-                it->dims_m1[i] = dims[i] - 1;
-                k = i - diff;
-                if ((k < 0) ||
-                    ao->dimensions[k] != dims[i]) {
-                        it->contiguous = 0;
-                        it->strides[i] = 0;
-                }
-                else {
-                        it->strides[i] = ao->strides[k];
-                }
-                it->backstrides[i] = it->strides[i] *   \
-                        it->dims_m1[i];
-                if (i > 0)
-                        it->factors[nd-i-1] = it->factors[nd-i] *       \
-                                dims[nd-i];
+    PyArray_UpdateFlags(ao, CONTIGUOUS);
+    if PyArray_ISCONTIGUOUS(ao) it->contiguous = 1;
+    else it->contiguous = 0;
+    Py_INCREF(ao);
+    it->ao = ao;
+    it->size = PyArray_MultiplyList(dims, nd);
+    it->nd_m1 = nd - 1;
+    it->factors[nd-1] = 1;
+    for (i=0; i < nd; i++) {
+        it->dims_m1[i] = dims[i] - 1;
+        k = i - diff;
+        if ((k < 0) ||
+            ao->dimensions[k] != dims[i]) {
+            it->contiguous = 0;
+            it->strides[i] = 0;
         }
-        PyArray_ITER_RESET(it);
+        else {
+            it->strides[i] = ao->strides[k];
+        }
+        it->backstrides[i] = it->strides[i] *   \
+            it->dims_m1[i];
+        if (i > 0)
+            it->factors[nd-i-1] = it->factors[nd-i] *       \
+                dims[nd-i];
+    }
+    PyArray_ITER_RESET(it);
 
-        return (PyObject *)it;
+    return (PyObject *)it;
 
  err:
-        PyErr_SetString(PyExc_ValueError, "array is not broadcastable to "\
-                        "correct shape");
-        return NULL;
+    PyErr_SetString(PyExc_ValueError, "array is not broadcastable to "\
+                    "correct shape");
+    return NULL;
 }
 
 
@@ -8931,49 +8930,49 @@ PyArray_BroadcastToShape(PyObject *obj, intp *dims, int nd)
 
 
 /*OBJECT_API
- Get Iterator that iterates over all but one axis (don't use this with
- PyArray_ITER_GOTO1D).  The axis will be over-written if negative
- with the axis having the smallest stride. 
+  Get Iterator that iterates over all but one axis (don't use this with
+  PyArray_ITER_GOTO1D).  The axis will be over-written if negative
+  with the axis having the smallest stride.
 */
 static PyObject *
 PyArray_IterAllButAxis(PyObject *obj, int *inaxis)
 {
-        PyArrayIterObject *it;
-        int axis;
-        it = (PyArrayIterObject *)PyArray_IterNew(obj);
-        if (it == NULL) return NULL;
-
-        if (PyArray_NDIM(obj)==0)
-                return (PyObject *)it;
-        if (*inaxis < 0) {
-                int i, minaxis=0;
-                intp minstride=0;
-                i = 0;
-                while (minstride==0 && i<PyArray_NDIM(obj)) {
-                        minstride = PyArray_STRIDE(obj,i);
-                        i++;
-                }
-                for (i=1; i<PyArray_NDIM(obj); i++) {
-                        if (PyArray_STRIDE(obj,i) > 0 && 
-                            PyArray_STRIDE(obj, i) < minstride) {
-                                minaxis = i;
-                                minstride = PyArray_STRIDE(obj,i);
-                        }
-                }
-                *inaxis = minaxis;
-        }
-        axis = *inaxis;
-        /* adjust so that will not iterate over axis */
-        it->contiguous = 0;
-        if (it->size != 0) {
-                it->size /= PyArray_DIM(obj,axis);
-        }
-        it->dims_m1[axis] = 0;
-        it->backstrides[axis] = 0;
+    PyArrayIterObject *it;
+    int axis;
+    it = (PyArrayIterObject *)PyArray_IterNew(obj);
+    if (it == NULL) return NULL;
 
-        /* (won't fix factors so don't use
-           PyArray_ITER_GOTO1D with this iterator) */
+    if (PyArray_NDIM(obj)==0)
         return (PyObject *)it;
+    if (*inaxis < 0) {
+        int i, minaxis=0;
+        intp minstride=0;
+        i = 0;
+        while (minstride==0 && i<PyArray_NDIM(obj)) {
+            minstride = PyArray_STRIDE(obj,i);
+            i++;
+        }
+        for (i=1; i<PyArray_NDIM(obj); i++) {
+            if (PyArray_STRIDE(obj,i) > 0 &&
+                PyArray_STRIDE(obj, i) < minstride) {
+                minaxis = i;
+                minstride = PyArray_STRIDE(obj,i);
+            }
+        }
+        *inaxis = minaxis;
+    }
+    axis = *inaxis;
+    /* adjust so that will not iterate over axis */
+    it->contiguous = 0;
+    if (it->size != 0) {
+        it->size /= PyArray_DIM(obj,axis);
+    }
+    it->dims_m1[axis] = 0;
+    it->backstrides[axis] = 0;
+
+    /* (won't fix factors so don't use
+       PyArray_ITER_GOTO1D with this iterator) */
+    return (PyObject *)it;
 }
 
 
@@ -8981,50 +8980,50 @@ PyArray_IterAllButAxis(PyObject *obj, int *inaxis)
    adjusted */
 
 /*OBJECT_API
-  Adjusts previously broadcasted iterators so that the axis with 
+  Adjusts previously broadcasted iterators so that the axis with
   the smallest sum of iterator strides is not iterated over.
   Returns dimension which is smallest in the range [0,multi->nd).
   A -1 is returned if multi->nd == 0.
- */
+*/
 static int
 PyArray_RemoveSmallest(PyArrayMultiIterObject *multi)
 {
-        PyArrayIterObject *it;
-        int i, j;
-        int axis;
-        intp smallest;
-        intp sumstrides[NPY_MAXDIMS];
+    PyArrayIterObject *it;
+    int i, j;
+    int axis;
+    intp smallest;
+    intp sumstrides[NPY_MAXDIMS];
 
-        if (multi->nd == 0) return -1;
+    if (multi->nd == 0) return -1;
 
 
-        for (i=0; i<multi->nd; i++) {
-                sumstrides[i] = 0;
-                for (j=0; j<multi->numiter; j++) {
-                        sumstrides[i] += multi->iters[j]->strides[i];
-                }
+    for (i=0; i<multi->nd; i++) {
+        sumstrides[i] = 0;
+        for (j=0; j<multi->numiter; j++) {
+            sumstrides[i] += multi->iters[j]->strides[i];
         }
-        axis=0;
-        smallest = sumstrides[0];
-        /* Find longest dimension */
-        for (i=1; i<multi->nd; i++) {
-                if (sumstrides[i] < smallest) {
-                        axis = i;
-                        smallest = sumstrides[i];
-                }
+    }
+    axis=0;
+    smallest = sumstrides[0];
+    /* Find longest dimension */
+    for (i=1; i<multi->nd; i++) {
+        if (sumstrides[i] < smallest) {
+            axis = i;
+            smallest = sumstrides[i];
         }
+    }
 
-        for (i=0; i<multi->numiter; i++) {
-                it = multi->iters[i];
-                it->contiguous = 0;
-                if (it->size != 0)
-                        it->size /= (it->dims_m1[axis]+1);
-                it->dims_m1[axis] = 0;
-                it->backstrides[axis] = 0;
-        }
+    for (i=0; i<multi->numiter; i++) {
+        it = multi->iters[i];
+        it->contiguous = 0;
+        if (it->size != 0)
+            it->size /= (it->dims_m1[axis]+1);
+        it->dims_m1[axis] = 0;
+        it->backstrides[axis] = 0;
+    }
 
-        multi->size = multi->iters[0]->size;
-        return axis;
+    multi->size = multi->iters[0]->size;
+    return axis;
 }
 
 /* Returns an array scalar holding the element desired */
@@ -9032,294 +9031,294 @@ PyArray_RemoveSmallest(PyArrayMultiIterObject *multi)
 static PyObject *
 arrayiter_next(PyArrayIterObject *it)
 {
-        PyObject *ret;
+    PyObject *ret;
 
-        if (it->index < it->size) {
-                ret = PyArray_ToScalar(it->dataptr, it->ao);
-                PyArray_ITER_NEXT(it);
-                return ret;
-        }
-        return NULL;
+    if (it->index < it->size) {
+        ret = PyArray_ToScalar(it->dataptr, it->ao);
+        PyArray_ITER_NEXT(it);
+        return ret;
+    }
+    return NULL;
 }
 
 static void
 arrayiter_dealloc(PyArrayIterObject *it)
 {
-        Py_XDECREF(it->ao);
-        _pya_free(it);
+    Py_XDECREF(it->ao);
+    _pya_free(it);
 }
 
 static Py_ssize_t
 iter_length(PyArrayIterObject *self)
 {
-        return self->size;
+    return self->size;
 }
 
 
 static PyObject *
 iter_subscript_Bool(PyArrayIterObject *self, PyArrayObject *ind)
 {
-        int index, strides, itemsize;
-        intp count=0;
-        char *dptr, *optr;
-        PyObject *r;
-        int swap;
-        PyArray_CopySwapFunc *copyswap;
+    int index, strides, itemsize;
+    intp count=0;
+    char *dptr, *optr;
+    PyObject *r;
+    int swap;
+    PyArray_CopySwapFunc *copyswap;
 
 
-        if (ind->nd != 1) {
-                PyErr_SetString(PyExc_ValueError,
-                                "boolean index array should have 1 dimension");
-                return NULL;
-        }
-        index = ind->dimensions[0];
-        if (index > self->size) {
-                PyErr_SetString(PyExc_ValueError,
-                                "too many boolean indices");
-                return NULL;
-        }
-
-        strides = ind->strides[0];
-        dptr = ind->data;
-        /* Get size of return array */
-        while(index--) {
-                if (*((Bool *)dptr) != 0)
-                        count++;
-                dptr += strides;
-        }
-        itemsize = self->ao->descr->elsize;
-        Py_INCREF(self->ao->descr);
-        r = PyArray_NewFromDescr(self->ao->ob_type,
-                                 self->ao->descr, 1, &count,
-                                 NULL, NULL,
-                                 0, (PyObject *)self->ao);
-        if (r==NULL) return NULL;
-
-        /* Set up loop */
-        optr = PyArray_DATA(r);
-        index = ind->dimensions[0];
-        dptr = ind->data;
+    if (ind->nd != 1) {
+        PyErr_SetString(PyExc_ValueError,
+                        "boolean index array should have 1 dimension");
+        return NULL;
+    }
+    index = ind->dimensions[0];
+    if (index > self->size) {
+        PyErr_SetString(PyExc_ValueError,
+                        "too many boolean indices");
+        return NULL;
+    }
 
-        copyswap = self->ao->descr->f->copyswap;
-        /* Loop over Boolean array */
-        swap = (PyArray_ISNOTSWAPPED(self->ao) != PyArray_ISNOTSWAPPED(r));
-        while(index--) {
-                if (*((Bool *)dptr) != 0) {
-                        copyswap(optr, self->dataptr, swap, self->ao);
-                        optr += itemsize;
-                }
-                dptr += strides;
-                PyArray_ITER_NEXT(self);
-        }
-        PyArray_ITER_RESET(self);
-        return r;
+    strides = ind->strides[0];
+    dptr = ind->data;
+    /* Get size of return array */
+    while(index--) {
+        if (*((Bool *)dptr) != 0)
+            count++;
+        dptr += strides;
+    }
+    itemsize = self->ao->descr->elsize;
+    Py_INCREF(self->ao->descr);
+    r = PyArray_NewFromDescr(self->ao->ob_type,
+                             self->ao->descr, 1, &count,
+                             NULL, NULL,
+                             0, (PyObject *)self->ao);
+    if (r==NULL) return NULL;
+
+    /* Set up loop */
+    optr = PyArray_DATA(r);
+    index = ind->dimensions[0];
+    dptr = ind->data;
+
+    copyswap = self->ao->descr->f->copyswap;
+    /* Loop over Boolean array */
+    swap = (PyArray_ISNOTSWAPPED(self->ao) != PyArray_ISNOTSWAPPED(r));
+    while(index--) {
+        if (*((Bool *)dptr) != 0) {
+            copyswap(optr, self->dataptr, swap, self->ao);
+            optr += itemsize;
+        }
+        dptr += strides;
+        PyArray_ITER_NEXT(self);
+    }
+    PyArray_ITER_RESET(self);
+    return r;
 }
 
 static PyObject *
 iter_subscript_int(PyArrayIterObject *self, PyArrayObject *ind)
 {
-        intp num;
-        PyObject *r;
-        PyArrayIterObject *ind_it;
-        int itemsize;
-        int swap;
-        char *optr;
-        int index;
-        PyArray_CopySwapFunc *copyswap;
-
-        itemsize = self->ao->descr->elsize;
-        if (ind->nd == 0) {
-                num = *((intp *)ind->data);
-                if (num < 0) num += self->size;
-                if (num < 0 || num >= self->size) {
-                        PyErr_Format(PyExc_IndexError,
-                                     "index %d out of bounds"   \
-                                     " 0<=index<%d", (int) num,
-                                     (int) self->size);
-                        r = NULL;
-                }
-                else {
-                        PyArray_ITER_GOTO1D(self, num);
-                        r = PyArray_ToScalar(self->dataptr, self->ao);
-                }
-                PyArray_ITER_RESET(self);
-                return r;
+    intp num;
+    PyObject *r;
+    PyArrayIterObject *ind_it;
+    int itemsize;
+    int swap;
+    char *optr;
+    int index;
+    PyArray_CopySwapFunc *copyswap;
+
+    itemsize = self->ao->descr->elsize;
+    if (ind->nd == 0) {
+        num = *((intp *)ind->data);
+        if (num < 0) num += self->size;
+        if (num < 0 || num >= self->size) {
+            PyErr_Format(PyExc_IndexError,
+                         "index %d out of bounds"   \
+                         " 0<=index<%d", (int) num,
+                         (int) self->size);
+            r = NULL;
         }
-
-        Py_INCREF(self->ao->descr);
-        r = PyArray_NewFromDescr(self->ao->ob_type, self->ao->descr,
-                                 ind->nd, ind->dimensions,
-                                 NULL, NULL,
-                                 0, (PyObject *)self->ao);
-        if (r==NULL) return NULL;
-
-        optr = PyArray_DATA(r);
-        ind_it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)ind);
-        if (ind_it == NULL) {Py_DECREF(r); return NULL;}
-        index = ind_it->size;
-        copyswap = PyArray_DESCR(r)->f->copyswap;
-        swap = (PyArray_ISNOTSWAPPED(r) != PyArray_ISNOTSWAPPED(self->ao));
-        while(index--) {
-                num = *((intp *)(ind_it->dataptr));
-                if (num < 0) num += self->size;
-                if (num < 0 || num >= self->size) {
-                        PyErr_Format(PyExc_IndexError,
-                                     "index %d out of bounds"           \
-                                     " 0<=index<%d", (int) num,
-                                     (int) self->size);
-                        Py_DECREF(ind_it);
-                        Py_DECREF(r);
-                        PyArray_ITER_RESET(self);
-                        return NULL;
-                }
-                PyArray_ITER_GOTO1D(self, num);
-                copyswap(optr, self->dataptr, swap, r);
-                optr += itemsize;
-                PyArray_ITER_NEXT(ind_it);
+        else {
+            PyArray_ITER_GOTO1D(self, num);
+            r = PyArray_ToScalar(self->dataptr, self->ao);
         }
-        Py_DECREF(ind_it);
         PyArray_ITER_RESET(self);
         return r;
+    }
+
+    Py_INCREF(self->ao->descr);
+    r = PyArray_NewFromDescr(self->ao->ob_type, self->ao->descr,
+                             ind->nd, ind->dimensions,
+                             NULL, NULL,
+                             0, (PyObject *)self->ao);
+    if (r==NULL) return NULL;
+
+    optr = PyArray_DATA(r);
+    ind_it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)ind);
+    if (ind_it == NULL) {Py_DECREF(r); return NULL;}
+    index = ind_it->size;
+    copyswap = PyArray_DESCR(r)->f->copyswap;
+    swap = (PyArray_ISNOTSWAPPED(r) != PyArray_ISNOTSWAPPED(self->ao));
+    while(index--) {
+        num = *((intp *)(ind_it->dataptr));
+        if (num < 0) num += self->size;
+        if (num < 0 || num >= self->size) {
+            PyErr_Format(PyExc_IndexError,
+                         "index %d out of bounds"           \
+                         " 0<=index<%d", (int) num,
+                         (int) self->size);
+            Py_DECREF(ind_it);
+            Py_DECREF(r);
+            PyArray_ITER_RESET(self);
+            return NULL;
+        }
+        PyArray_ITER_GOTO1D(self, num);
+        copyswap(optr, self->dataptr, swap, r);
+        optr += itemsize;
+        PyArray_ITER_NEXT(ind_it);
+    }
+    Py_DECREF(ind_it);
+    PyArray_ITER_RESET(self);
+    return r;
 }
 
 
 static PyObject *
 iter_subscript(PyArrayIterObject *self, PyObject *ind)
 {
-        PyArray_Descr *indtype=NULL;
-        intp start, step_size;
-        intp n_steps;
-        PyObject *r;
-        char *dptr;
-        int size;
-        PyObject *obj = NULL;
-        int swap;
-        PyArray_CopySwapFunc *copyswap;
-
-        if (ind == Py_Ellipsis) {
-                ind = PySlice_New(NULL, NULL, NULL);
-                obj = iter_subscript(self, ind);
-                Py_DECREF(ind);
-                return obj;
-        }
-        if (PyTuple_Check(ind)) {
-                int len;
-                len = PyTuple_GET_SIZE(ind);
-                if (len > 1) goto fail;
-                if (len == 0) {
-                        Py_INCREF(self->ao);
-                        return (PyObject *)self->ao;
-                }
-                ind = PyTuple_GET_ITEM(ind, 0);
+    PyArray_Descr *indtype=NULL;
+    intp start, step_size;
+    intp n_steps;
+    PyObject *r;
+    char *dptr;
+    int size;
+    PyObject *obj = NULL;
+    int swap;
+    PyArray_CopySwapFunc *copyswap;
+
+    if (ind == Py_Ellipsis) {
+        ind = PySlice_New(NULL, NULL, NULL);
+        obj = iter_subscript(self, ind);
+        Py_DECREF(ind);
+        return obj;
+    }
+    if (PyTuple_Check(ind)) {
+        int len;
+        len = PyTuple_GET_SIZE(ind);
+        if (len > 1) goto fail;
+        if (len == 0) {
+            Py_INCREF(self->ao);
+            return (PyObject *)self->ao;
         }
+        ind = PyTuple_GET_ITEM(ind, 0);
+    }
 
-        /* Tuples >1d not accepted --- i.e. no newaxis */
-        /* Could implement this with adjusted strides
-           and dimensions in iterator */
+    /* Tuples >1d not accepted --- i.e. no newaxis */
+    /* Could implement this with adjusted strides
+       and dimensions in iterator */
 
-        /* Check for Boolean -- this is first becasue
-           Bool is a subclass of Int */
-        PyArray_ITER_RESET(self);
+    /* Check for Boolean -- this is first becasue
+       Bool is a subclass of Int */
+    PyArray_ITER_RESET(self);
 
-        if (PyBool_Check(ind)) {
-                if (PyObject_IsTrue(ind)) {
-                        return PyArray_ToScalar(self->dataptr, self->ao);
-                }
-                else { /* empty array */
-                        intp ii = 0;
-                        Py_INCREF(self->ao->descr);
-                        r = PyArray_NewFromDescr(self->ao->ob_type,
-                                                 self->ao->descr,
-                                                 1, &ii,
-                                                 NULL, NULL, 0,
-                                                 (PyObject *)self->ao);
-                        return r;
-                }
+    if (PyBool_Check(ind)) {
+        if (PyObject_IsTrue(ind)) {
+            return PyArray_ToScalar(self->dataptr, self->ao);
         }
+        else { /* empty array */
+            intp ii = 0;
+            Py_INCREF(self->ao->descr);
+            r = PyArray_NewFromDescr(self->ao->ob_type,
+                                     self->ao->descr,
+                                     1, &ii,
+                                     NULL, NULL, 0,
+                                     (PyObject *)self->ao);
+            return r;
+        }
+    }
 
-        /* Check for Integer or Slice */
-
-        if (PyLong_Check(ind) || PyInt_Check(ind) || PySlice_Check(ind)) {
-                start = parse_subindex(ind, &step_size, &n_steps,
-                                       self->size);
-                if (start == -1)
-                        goto fail;
-                if (n_steps == RubberIndex || n_steps == PseudoIndex) {
-                        PyErr_SetString(PyExc_IndexError,
-                                        "cannot use Ellipsis or newaxes here");
-                        goto fail;
-                }
-                PyArray_ITER_GOTO1D(self, start)
-                if (n_steps == SingleIndex) { /* Integer */
-                        r = PyArray_ToScalar(self->dataptr, self->ao);
-                        PyArray_ITER_RESET(self);
-                        return r;
-                }
-                size = self->ao->descr->elsize;
-                Py_INCREF(self->ao->descr);
-                r = PyArray_NewFromDescr(self->ao->ob_type,
-                                         self->ao->descr,
-                                         1, &n_steps,
-                                         NULL, NULL,
-                                         0, (PyObject *)self->ao);
-                if (r==NULL) goto fail;
-                dptr = PyArray_DATA(r);
-                swap = !PyArray_ISNOTSWAPPED(self->ao);
-                copyswap = PyArray_DESCR(r)->f->copyswap;
-                while(n_steps--) {
-                        copyswap(dptr, self->dataptr, swap, r);
-                        start += step_size;
-                        PyArray_ITER_GOTO1D(self, start)
-                        dptr += size;
-                }
+    /* Check for Integer or Slice */
+
+    if (PyLong_Check(ind) || PyInt_Check(ind) || PySlice_Check(ind)) {
+        start = parse_subindex(ind, &step_size, &n_steps,
+                               self->size);
+        if (start == -1)
+            goto fail;
+        if (n_steps == RubberIndex || n_steps == PseudoIndex) {
+            PyErr_SetString(PyExc_IndexError,
+                            "cannot use Ellipsis or newaxes here");
+            goto fail;
+        }
+        PyArray_ITER_GOTO1D(self, start)
+            if (n_steps == SingleIndex) { /* Integer */
+                r = PyArray_ToScalar(self->dataptr, self->ao);
                 PyArray_ITER_RESET(self);
                 return r;
+            }
+        size = self->ao->descr->elsize;
+        Py_INCREF(self->ao->descr);
+        r = PyArray_NewFromDescr(self->ao->ob_type,
+                                 self->ao->descr,
+                                 1, &n_steps,
+                                 NULL, NULL,
+                                 0, (PyObject *)self->ao);
+        if (r==NULL) goto fail;
+        dptr = PyArray_DATA(r);
+        swap = !PyArray_ISNOTSWAPPED(self->ao);
+        copyswap = PyArray_DESCR(r)->f->copyswap;
+        while(n_steps--) {
+            copyswap(dptr, self->dataptr, swap, r);
+            start += step_size;
+            PyArray_ITER_GOTO1D(self, start)
+                dptr += size;
         }
+        PyArray_ITER_RESET(self);
+        return r;
+    }
 
-        /* convert to INTP array if Integer array scalar or List */
+    /* convert to INTP array if Integer array scalar or List */
 
-        indtype = PyArray_DescrFromType(PyArray_INTP);
-        if (PyArray_IsScalar(ind, Integer) || PyList_Check(ind)) {
-                Py_INCREF(indtype);
-                obj = PyArray_FromAny(ind, indtype, 0, 0, FORCECAST, NULL);
-                if (obj == NULL) goto fail;
+    indtype = PyArray_DescrFromType(PyArray_INTP);
+    if (PyArray_IsScalar(ind, Integer) || PyList_Check(ind)) {
+        Py_INCREF(indtype);
+        obj = PyArray_FromAny(ind, indtype, 0, 0, FORCECAST, NULL);
+        if (obj == NULL) goto fail;
+    }
+    else {
+        Py_INCREF(ind);
+        obj = ind;
+    }
+
+    if (PyArray_Check(obj)) {
+        /* Check for Boolean object */
+        if (PyArray_TYPE(obj)==PyArray_BOOL) {
+            r = iter_subscript_Bool(self, (PyArrayObject *)obj);
+            Py_DECREF(indtype);
+        }
+        /* Check for integer array */
+        else if (PyArray_ISINTEGER(obj)) {
+            PyObject *new;
+            new = PyArray_FromAny(obj, indtype, 0, 0,
+                                  FORCECAST | ALIGNED, NULL);
+            if (new==NULL) goto fail;
+            Py_DECREF(obj);
+            obj = new;
+            r = iter_subscript_int(self, (PyArrayObject *)obj);
         }
         else {
-                Py_INCREF(ind);
-                obj = ind;
-        }
-
-        if (PyArray_Check(obj)) {
-                /* Check for Boolean object */
-                if (PyArray_TYPE(obj)==PyArray_BOOL) {
-                        r = iter_subscript_Bool(self, (PyArrayObject *)obj);
-                        Py_DECREF(indtype);
-                }
-                /* Check for integer array */
-                else if (PyArray_ISINTEGER(obj)) {
-                        PyObject *new;
-                        new = PyArray_FromAny(obj, indtype, 0, 0,
-                                              FORCECAST | ALIGNED, NULL);
-                        if (new==NULL) goto fail;
-                        Py_DECREF(obj);
-                        obj = new;
-                        r = iter_subscript_int(self, (PyArrayObject *)obj);
-                }
-                else {
-                        goto fail;
-                }
-                Py_DECREF(obj);
-                return r;
+            goto fail;
         }
-        else Py_DECREF(indtype);
+        Py_DECREF(obj);
+        return r;
+    }
+    else Py_DECREF(indtype);
 
 
  fail:
-        if (!PyErr_Occurred())
-                PyErr_SetString(PyExc_IndexError, "unsupported iterator index");
-        Py_XDECREF(indtype);
-        Py_XDECREF(obj);
-        return NULL;
+    if (!PyErr_Occurred())
+        PyErr_SetString(PyExc_IndexError, "unsupported iterator index");
+    Py_XDECREF(indtype);
+    Py_XDECREF(obj);
+    return NULL;
 
 }
 
@@ -9328,241 +9327,241 @@ static int
 iter_ass_sub_Bool(PyArrayIterObject *self, PyArrayObject *ind,
                   PyArrayIterObject *val, int swap)
 {
-        int index, strides;
-        char *dptr;
-        PyArray_CopySwapFunc *copyswap;
+    int index, strides;
+    char *dptr;
+    PyArray_CopySwapFunc *copyswap;
 
-        if (ind->nd != 1) {
-                PyErr_SetString(PyExc_ValueError,
-                                "boolean index array should have 1 dimension");
-                return -1;
-        }
-        index = ind->dimensions[0];
-        strides = ind->strides[0];
-        dptr = ind->data;
-        PyArray_ITER_RESET(self);
-        /* Loop over Boolean array */
-        copyswap = self->ao->descr->f->copyswap;
-        while(index--) {
-                if (*((Bool *)dptr) != 0) {
-                        copyswap(self->dataptr, val->dataptr, swap, self->ao);
-                        PyArray_ITER_NEXT(val);
-                        if (val->index==val->size)
-                                PyArray_ITER_RESET(val);
-                }
-                dptr += strides;
-                PyArray_ITER_NEXT(self);
-        }
-        PyArray_ITER_RESET(self);
-        return 0;
+    if (ind->nd != 1) {
+        PyErr_SetString(PyExc_ValueError,
+                        "boolean index array should have 1 dimension");
+        return -1;
+    }
+    index = ind->dimensions[0];
+    strides = ind->strides[0];
+    dptr = ind->data;
+    PyArray_ITER_RESET(self);
+    /* Loop over Boolean array */
+    copyswap = self->ao->descr->f->copyswap;
+    while(index--) {
+        if (*((Bool *)dptr) != 0) {
+            copyswap(self->dataptr, val->dataptr, swap, self->ao);
+            PyArray_ITER_NEXT(val);
+            if (val->index==val->size)
+                PyArray_ITER_RESET(val);
+        }
+        dptr += strides;
+        PyArray_ITER_NEXT(self);
+    }
+    PyArray_ITER_RESET(self);
+    return 0;
 }
 
 static int
 iter_ass_sub_int(PyArrayIterObject *self, PyArrayObject *ind,
-                   PyArrayIterObject *val, int swap)
-{
-        PyArray_Descr *typecode;
-        intp num;
-        PyArrayIterObject *ind_it;
-        int index;
-        PyArray_CopySwapFunc *copyswap;
-
-        typecode = self->ao->descr;
-        copyswap = self->ao->descr->f->copyswap;
-        if (ind->nd == 0) {
-                num = *((intp *)ind->data);
-                PyArray_ITER_GOTO1D(self, num);
-                copyswap(self->dataptr, val->dataptr, swap, self->ao);
-                return 0;
-        }
-        ind_it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)ind);
-        if (ind_it == NULL) return -1;
-        index = ind_it->size;
-        while(index--) {
-                num = *((intp *)(ind_it->dataptr));
-                if (num < 0) num += self->size;
-                if ((num < 0) || (num >= self->size)) {
-                        PyErr_Format(PyExc_IndexError,
-                                     "index %d out of bounds"           \
-                                     " 0<=index<%d", (int) num,
-                                     (int) self->size);
-                        Py_DECREF(ind_it);
-                        return -1;
-                }
-                PyArray_ITER_GOTO1D(self, num);
-                copyswap(self->dataptr, val->dataptr, swap, self->ao);
-                PyArray_ITER_NEXT(ind_it);
-                PyArray_ITER_NEXT(val);
-                if (val->index == val->size)
-                        PyArray_ITER_RESET(val);
-        }
-        Py_DECREF(ind_it);
+                 PyArrayIterObject *val, int swap)
+{
+    PyArray_Descr *typecode;
+    intp num;
+    PyArrayIterObject *ind_it;
+    int index;
+    PyArray_CopySwapFunc *copyswap;
+
+    typecode = self->ao->descr;
+    copyswap = self->ao->descr->f->copyswap;
+    if (ind->nd == 0) {
+        num = *((intp *)ind->data);
+        PyArray_ITER_GOTO1D(self, num);
+        copyswap(self->dataptr, val->dataptr, swap, self->ao);
         return 0;
+    }
+    ind_it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)ind);
+    if (ind_it == NULL) return -1;
+    index = ind_it->size;
+    while(index--) {
+        num = *((intp *)(ind_it->dataptr));
+        if (num < 0) num += self->size;
+        if ((num < 0) || (num >= self->size)) {
+            PyErr_Format(PyExc_IndexError,
+                         "index %d out of bounds"           \
+                         " 0<=index<%d", (int) num,
+                         (int) self->size);
+            Py_DECREF(ind_it);
+            return -1;
+        }
+        PyArray_ITER_GOTO1D(self, num);
+        copyswap(self->dataptr, val->dataptr, swap, self->ao);
+        PyArray_ITER_NEXT(ind_it);
+        PyArray_ITER_NEXT(val);
+        if (val->index == val->size)
+            PyArray_ITER_RESET(val);
+    }
+    Py_DECREF(ind_it);
+    return 0;
 }
 
 static int
 iter_ass_subscript(PyArrayIterObject *self, PyObject *ind, PyObject *val)
 {
-        PyObject *arrval=NULL;
-        PyArrayIterObject *val_it=NULL;
-        PyArray_Descr *type;
-        PyArray_Descr *indtype=NULL;
-        int swap, retval=-1;
-        intp start, step_size;
-        intp n_steps;
-        PyObject *obj=NULL;
-        PyArray_CopySwapFunc *copyswap;
-
-
-        if (ind == Py_Ellipsis) {
-                ind = PySlice_New(NULL, NULL, NULL);
-                retval = iter_ass_subscript(self, ind, val);
-                Py_DECREF(ind);
-                return retval;
-        }
+    PyObject *arrval=NULL;
+    PyArrayIterObject *val_it=NULL;
+    PyArray_Descr *type;
+    PyArray_Descr *indtype=NULL;
+    int swap, retval=-1;
+    intp start, step_size;
+    intp n_steps;
+    PyObject *obj=NULL;
+    PyArray_CopySwapFunc *copyswap;
+
+
+    if (ind == Py_Ellipsis) {
+        ind = PySlice_New(NULL, NULL, NULL);
+        retval = iter_ass_subscript(self, ind, val);
+        Py_DECREF(ind);
+        return retval;
+    }
 
-        if (PyTuple_Check(ind)) {
-                int len;
-                len = PyTuple_GET_SIZE(ind);
-                if (len > 1) goto finish;
-                ind = PyTuple_GET_ITEM(ind, 0);
-        }
+    if (PyTuple_Check(ind)) {
+        int len;
+        len = PyTuple_GET_SIZE(ind);
+        if (len > 1) goto finish;
+        ind = PyTuple_GET_ITEM(ind, 0);
+    }
 
-        type = self->ao->descr;
+    type = self->ao->descr;
 
-        /* Check for Boolean -- this is first becasue
-           Bool is a subclass of Int */
+    /* Check for Boolean -- this is first becasue
+       Bool is a subclass of Int */
 
-        if (PyBool_Check(ind)) {
-                retval = 0;
-                if (PyObject_IsTrue(ind)) {
-                        retval = type->f->setitem(val, self->dataptr, self->ao);
-                }
-                goto finish;
+    if (PyBool_Check(ind)) {
+        retval = 0;
+        if (PyObject_IsTrue(ind)) {
+            retval = type->f->setitem(val, self->dataptr, self->ao);
         }
+        goto finish;
+    }
 
-        if (PySequence_Check(ind) || PySlice_Check(ind)) goto skip;
-        start = PyArray_PyIntAsIntp(ind);
-        if (start==-1 && PyErr_Occurred()) PyErr_Clear();
-        else {
-                if (start < -self->size || start >= self->size) {
-                        PyErr_Format(PyExc_ValueError,
-                                     "index (%" NPY_INTP_FMT \
-                                     ") out of range", start);
-                        goto finish;
-                }
-                retval = 0;
-                PyArray_ITER_GOTO1D(self, start);
-                retval = type->f->setitem(val, self->dataptr, self->ao);
-                PyArray_ITER_RESET(self);
-                if (retval < 0) {
-                        PyErr_SetString(PyExc_ValueError, 
-                                        "Error setting single item of array.");
-                }
-                goto finish;
+    if (PySequence_Check(ind) || PySlice_Check(ind)) goto skip;
+    start = PyArray_PyIntAsIntp(ind);
+    if (start==-1 && PyErr_Occurred()) PyErr_Clear();
+    else {
+        if (start < -self->size || start >= self->size) {
+            PyErr_Format(PyExc_ValueError,
+                         "index (%" NPY_INTP_FMT \
+                         ") out of range", start);
+            goto finish;
         }
+        retval = 0;
+        PyArray_ITER_GOTO1D(self, start);
+        retval = type->f->setitem(val, self->dataptr, self->ao);
+        PyArray_ITER_RESET(self);
+        if (retval < 0) {
+            PyErr_SetString(PyExc_ValueError,
+                            "Error setting single item of array.");
+        }
+        goto finish;
+    }
 
  skip:
-        Py_INCREF(type);
-        arrval = PyArray_FromAny(val, type, 0, 0, 0, NULL);
-        if (arrval==NULL) return -1;
-        val_it = (PyArrayIterObject *)PyArray_IterNew(arrval);
-        if (val_it==NULL) goto finish;
-        if (val_it->size == 0) {retval = 0; goto finish;}
-
-        copyswap = PyArray_DESCR(arrval)->f->copyswap;
-        swap = (PyArray_ISNOTSWAPPED(self->ao)!=PyArray_ISNOTSWAPPED(arrval));
-        
-        /* Check Slice */
-
-        if (PySlice_Check(ind)) {
-                start = parse_subindex(ind, &step_size, &n_steps,
-                                       self->size);
-                if (start == -1) goto finish;
-                if (n_steps == RubberIndex || n_steps == PseudoIndex) {
-                        PyErr_SetString(PyExc_IndexError,
-                                        "cannot use Ellipsis or newaxes here");
-                        goto finish;
-                }
-                PyArray_ITER_GOTO1D(self, start);
-                if (n_steps == SingleIndex) { /* Integer */
-                        copyswap(self->dataptr, PyArray_DATA(arrval),
-                                  swap, arrval);
-                        PyArray_ITER_RESET(self);
-                        retval=0;
-                        goto finish;
-                }
-                while(n_steps--) {
-                        copyswap(self->dataptr, val_it->dataptr,
-                                  swap, arrval);
-                        start += step_size;
-                        PyArray_ITER_GOTO1D(self, start)
-                        PyArray_ITER_NEXT(val_it);
-                        if (val_it->index == val_it->size)
-                                PyArray_ITER_RESET(val_it);
-                }
-                PyArray_ITER_RESET(self);
-                retval = 0;
-                goto finish;
+    Py_INCREF(type);
+    arrval = PyArray_FromAny(val, type, 0, 0, 0, NULL);
+    if (arrval==NULL) return -1;
+    val_it = (PyArrayIterObject *)PyArray_IterNew(arrval);
+    if (val_it==NULL) goto finish;
+    if (val_it->size == 0) {retval = 0; goto finish;}
+
+    copyswap = PyArray_DESCR(arrval)->f->copyswap;
+    swap = (PyArray_ISNOTSWAPPED(self->ao)!=PyArray_ISNOTSWAPPED(arrval));
+
+    /* Check Slice */
+
+    if (PySlice_Check(ind)) {
+        start = parse_subindex(ind, &step_size, &n_steps,
+                               self->size);
+        if (start == -1) goto finish;
+        if (n_steps == RubberIndex || n_steps == PseudoIndex) {
+            PyErr_SetString(PyExc_IndexError,
+                            "cannot use Ellipsis or newaxes here");
+            goto finish;
         }
-
-        /* convert to INTP array if Integer array scalar or List */
-
-        indtype = PyArray_DescrFromType(PyArray_INTP);
-        if (PyList_Check(ind)) {
-                Py_INCREF(indtype);
-                obj = PyArray_FromAny(ind, indtype, 0, 0, FORCECAST, NULL);
+        PyArray_ITER_GOTO1D(self, start);
+        if (n_steps == SingleIndex) { /* Integer */
+            copyswap(self->dataptr, PyArray_DATA(arrval),
+                     swap, arrval);
+            PyArray_ITER_RESET(self);
+            retval=0;
+            goto finish;
         }
-        else {
-                Py_INCREF(ind);
-                obj = ind;
+        while(n_steps--) {
+            copyswap(self->dataptr, val_it->dataptr,
+                     swap, arrval);
+            start += step_size;
+            PyArray_ITER_GOTO1D(self, start)
+                PyArray_ITER_NEXT(val_it);
+            if (val_it->index == val_it->size)
+                PyArray_ITER_RESET(val_it);
         }
+        PyArray_ITER_RESET(self);
+        retval = 0;
+        goto finish;
+    }
 
-        if (obj != NULL && PyArray_Check(obj)) {
-                /* Check for Boolean object */
-                if (PyArray_TYPE(obj)==PyArray_BOOL) {
-                        if (iter_ass_sub_Bool(self, (PyArrayObject *)obj,
-                                              val_it, swap) < 0)
-                                goto finish;
-                        retval=0;
-                }
-                /* Check for integer array */
-                else if (PyArray_ISINTEGER(obj)) {
-                        PyObject *new;
-                        Py_INCREF(indtype);
-                        new = PyArray_CheckFromAny(obj, indtype, 0, 0,
-                                                   FORCECAST | BEHAVED_NS, NULL);
-                        Py_DECREF(obj);
-                        obj = new;
-                        if (new==NULL) goto finish;
-                        if (iter_ass_sub_int(self, (PyArrayObject *)obj,
-                                             val_it, swap) < 0)
-                                goto finish;
-                        retval=0;
-                }
+    /* convert to INTP array if Integer array scalar or List */
+
+    indtype = PyArray_DescrFromType(PyArray_INTP);
+    if (PyList_Check(ind)) {
+        Py_INCREF(indtype);
+        obj = PyArray_FromAny(ind, indtype, 0, 0, FORCECAST, NULL);
+    }
+    else {
+        Py_INCREF(ind);
+        obj = ind;
+    }
+
+    if (obj != NULL && PyArray_Check(obj)) {
+        /* Check for Boolean object */
+        if (PyArray_TYPE(obj)==PyArray_BOOL) {
+            if (iter_ass_sub_Bool(self, (PyArrayObject *)obj,
+                                  val_it, swap) < 0)
+                goto finish;
+            retval=0;
+        }
+        /* Check for integer array */
+        else if (PyArray_ISINTEGER(obj)) {
+            PyObject *new;
+            Py_INCREF(indtype);
+            new = PyArray_CheckFromAny(obj, indtype, 0, 0,
+                                       FORCECAST | BEHAVED_NS, NULL);
+            Py_DECREF(obj);
+            obj = new;
+            if (new==NULL) goto finish;
+            if (iter_ass_sub_int(self, (PyArrayObject *)obj,
+                                 val_it, swap) < 0)
+                goto finish;
+            retval=0;
         }
+    }
 
  finish:
-        if (!PyErr_Occurred() && retval < 0)
-                PyErr_SetString(PyExc_IndexError,
-                                "unsupported iterator index");
-        Py_XDECREF(indtype);
-        Py_XDECREF(obj);
-        Py_XDECREF(val_it);
-        Py_XDECREF(arrval);
-        return retval;
+    if (!PyErr_Occurred() && retval < 0)
+        PyErr_SetString(PyExc_IndexError,
+                        "unsupported iterator index");
+    Py_XDECREF(indtype);
+    Py_XDECREF(obj);
+    Py_XDECREF(val_it);
+    Py_XDECREF(arrval);
+    return retval;
 
 }
 
 
 static PyMappingMethods iter_as_mapping = {
 #if PY_VERSION_HEX >= 0x02050000
-        (lenfunc)iter_length,                   /*mp_length*/
+    (lenfunc)iter_length,                   /*mp_length*/
 #else
-        (inquiry)iter_length,                   /*mp_length*/
+    (inquiry)iter_length,                   /*mp_length*/
 #endif
-        (binaryfunc)iter_subscript,             /*mp_subscript*/
-        (objobjargproc)iter_ass_subscript,      /*mp_ass_subscript*/
+    (binaryfunc)iter_subscript,             /*mp_subscript*/
+    (objobjargproc)iter_ass_subscript,      /*mp_ass_subscript*/
 };
 
 
@@ -9571,143 +9570,143 @@ static PyObject *
 iter_array(PyArrayIterObject *it, PyObject *op)
 {
 
-        PyObject *r;
-        intp size;
-
-        /* Any argument ignored */
-
-        /* Two options:
-            1) underlying array is contiguous
-               -- return 1-d wrapper around it
-            2) underlying array is not contiguous
-               -- make new 1-d contiguous array with updateifcopy flag set
-                  to copy back to the old array
-        */
-
-        size = PyArray_SIZE(it->ao);
-        Py_INCREF(it->ao->descr);
-        if (PyArray_ISCONTIGUOUS(it->ao)) {
-                r = PyArray_NewFromDescr(&PyArray_Type,
-                                         it->ao->descr,
-                                         1, &size,
-                                         NULL, it->ao->data,
-                                         it->ao->flags,
-                                         (PyObject *)it->ao);
-                if (r==NULL) return NULL;
-        }
-        else {
-                r = PyArray_NewFromDescr(&PyArray_Type,
-                                         it->ao->descr,
-                                         1, &size,
-                                         NULL, NULL,
-                                         0, (PyObject *)it->ao);
-                if (r==NULL) return NULL;
-                if (_flat_copyinto(r, (PyObject *)it->ao,
-                                   PyArray_CORDER) < 0) {
-                        Py_DECREF(r);
-                        return NULL;
-                }
-                PyArray_FLAGS(r) |= UPDATEIFCOPY;
-                it->ao->flags &= ~WRITEABLE;
+    PyObject *r;
+    intp size;
+
+    /* Any argument ignored */
+
+    /* Two options:
+       1) underlying array is contiguous
+       -- return 1-d wrapper around it
+       2) underlying array is not contiguous
+       -- make new 1-d contiguous array with updateifcopy flag set
+       to copy back to the old array
+    */
+
+    size = PyArray_SIZE(it->ao);
+    Py_INCREF(it->ao->descr);
+    if (PyArray_ISCONTIGUOUS(it->ao)) {
+        r = PyArray_NewFromDescr(&PyArray_Type,
+                                 it->ao->descr,
+                                 1, &size,
+                                 NULL, it->ao->data,
+                                 it->ao->flags,
+                                 (PyObject *)it->ao);
+        if (r==NULL) return NULL;
+    }
+    else {
+        r = PyArray_NewFromDescr(&PyArray_Type,
+                                 it->ao->descr,
+                                 1, &size,
+                                 NULL, NULL,
+                                 0, (PyObject *)it->ao);
+        if (r==NULL) return NULL;
+        if (_flat_copyinto(r, (PyObject *)it->ao,
+                           PyArray_CORDER) < 0) {
+            Py_DECREF(r);
+            return NULL;
         }
-        Py_INCREF(it->ao);
-        PyArray_BASE(r) = (PyObject *)it->ao;
-        return r;
+        PyArray_FLAGS(r) |= UPDATEIFCOPY;
+        it->ao->flags &= ~WRITEABLE;
+    }
+    Py_INCREF(it->ao);
+    PyArray_BASE(r) = (PyObject *)it->ao;
+    return r;
 
 }
 
 static PyObject *
 iter_copy(PyArrayIterObject *it, PyObject *args)
 {
-        if (!PyArg_ParseTuple(args, "")) return NULL;
-        return PyArray_Flatten(it->ao, 0);
+    if (!PyArg_ParseTuple(args, "")) return NULL;
+    return PyArray_Flatten(it->ao, 0);
 }
 
 static PyMethodDef iter_methods[] = {
-        /* to get array */
-        {"__array__", (PyCFunction)iter_array, 1, NULL},
-        {"copy", (PyCFunction)iter_copy, 1, NULL},
-        {NULL,          NULL}           /* sentinel */
+    /* to get array */
+    {"__array__", (PyCFunction)iter_array, 1, NULL},
+    {"copy", (PyCFunction)iter_copy, 1, NULL},
+    {NULL,          NULL}           /* sentinel */
 };
 
 static PyObject *
 iter_richcompare(PyArrayIterObject *self, PyObject *other, int cmp_op)
 {
-        PyArrayObject *new;
-        PyObject *ret;
-        new = (PyArrayObject *)iter_array(self, NULL);
-        if (new == NULL) return NULL;
-        ret = array_richcompare(new, other, cmp_op);
-        Py_DECREF(new);
-        return ret;
+    PyArrayObject *new;
+    PyObject *ret;
+    new = (PyArrayObject *)iter_array(self, NULL);
+    if (new == NULL) return NULL;
+    ret = array_richcompare(new, other, cmp_op);
+    Py_DECREF(new);
+    return ret;
 }
 
 
 static PyMemberDef iter_members[] = {
-        {"base", T_OBJECT, offsetof(PyArrayIterObject, ao), RO, NULL},
-        {"index", T_INT, offsetof(PyArrayIterObject, index), RO, NULL},
-        {NULL},
+    {"base", T_OBJECT, offsetof(PyArrayIterObject, ao), RO, NULL},
+    {"index", T_INT, offsetof(PyArrayIterObject, index), RO, NULL},
+    {NULL},
 };
 
 static PyObject *
 iter_coords_get(PyArrayIterObject *self)
 {
-        int nd;
-        nd = self->ao->nd;
-        if (self->contiguous) { /* coordinates not kept track of --- need to generate
-                                   from index */
-                intp val;
-                int i;
-                val = self->index;
-                for (i=0;i<nd; i++) {
-                        self->coordinates[i] = val / self->factors[i];
-                        val = val % self->factors[i];
-                }
+    int nd;
+    nd = self->ao->nd;
+    if (self->contiguous) { /* coordinates not kept track of --- need to generate
+                               from index */
+        intp val;
+        int i;
+        val = self->index;
+        for (i=0;i<nd; i++) {
+            self->coordinates[i] = val / self->factors[i];
+            val = val % self->factors[i];
         }
-        return PyArray_IntTupleFromIntp(nd, self->coordinates);
+    }
+    return PyArray_IntTupleFromIntp(nd, self->coordinates);
 }
 
 static PyGetSetDef iter_getsets[] = {
-        {"coords",
-         (getter)iter_coords_get,
-         NULL,
-         NULL},
-        {NULL, NULL, NULL, NULL},
+    {"coords",
+     (getter)iter_coords_get,
+     NULL,
+     NULL},
+    {NULL, NULL, NULL, NULL},
 };
 
 static PyTypeObject PyArrayIter_Type = {
-        PyObject_HEAD_INIT(NULL)
-        0,                                       /* ob_size */
-        "numpy.flatiter",                        /* tp_name */
-        sizeof(PyArrayIterObject),               /* 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 */
-        &iter_as_mapping,                       /* tp_as_mapping */
-        0,                                      /* tp_hash */
-        0,                                      /* tp_call */
-        0,                                      /* tp_str */
-        0,                                      /* tp_getattro */
-        0,                                      /* tp_setattro */
-        0,                                      /* tp_as_buffer */
-        Py_TPFLAGS_DEFAULT,                     /* tp_flags */
-        0,                                      /* tp_doc */
-        0,                                      /* tp_traverse */
-        0,                                      /* tp_clear */
-        (richcmpfunc)iter_richcompare,          /* tp_richcompare */
-        0,                                      /* tp_weaklistoffset */
-        0,                              /* tp_iter */
-        (iternextfunc)arrayiter_next,           /* tp_iternext */
-        iter_methods,                           /* tp_methods */
-        iter_members,                   /* tp_members */
-        iter_getsets,                           /* tp_getset */
+    PyObject_HEAD_INIT(NULL)
+    0,                                       /* ob_size */
+    "numpy.flatiter",                        /* tp_name */
+    sizeof(PyArrayIterObject),               /* 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 */
+    &iter_as_mapping,                       /* tp_as_mapping */
+    0,                                      /* tp_hash */
+    0,                                      /* tp_call */
+    0,                                      /* tp_str */
+    0,                                      /* tp_getattro */
+    0,                                      /* tp_setattro */
+    0,                                      /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                     /* tp_flags */
+    0,                                      /* tp_doc */
+    0,                                      /* tp_traverse */
+    0,                                      /* tp_clear */
+    (richcmpfunc)iter_richcompare,          /* tp_richcompare */
+    0,                                      /* tp_weaklistoffset */
+    0,                              /* tp_iter */
+    (iternextfunc)arrayiter_next,           /* tp_iternext */
+    iter_methods,                           /* tp_methods */
+    iter_members,                   /* tp_members */
+    iter_getsets,                           /* tp_getset */
 
 };
 
@@ -9730,147 +9729,147 @@ static int _nonzero_indices(PyObject *myBool, PyArrayIterObject **iters);
    if possible -- otherwise, it is a Slice or Ellipsis object
    and has to be interpreted on bind to a particular
    array so leave it NULL for now.
- */
+*/
 static int
 _convert_obj(PyObject *obj, PyArrayIterObject **iter)
 {
-        PyArray_Descr *indtype;
-        PyObject *arr;
+    PyArray_Descr *indtype;
+    PyObject *arr;
 
-        if (PySlice_Check(obj) || (obj == Py_Ellipsis))
-                return 0;
-        else if (PyArray_Check(obj) && PyArray_ISBOOL(obj)) {
-                return _nonzero_indices(obj, iter);
-        }
-        else {
-                indtype = PyArray_DescrFromType(PyArray_INTP);
-                arr = PyArray_FromAny(obj, indtype, 0, 0, FORCECAST, NULL);
-                if (arr == NULL) return -1;
-                *iter = (PyArrayIterObject *)PyArray_IterNew(arr);
-                Py_DECREF(arr);
-                if (*iter == NULL) return -1;
-        }
-        return 1;
+    if (PySlice_Check(obj) || (obj == Py_Ellipsis))
+        return 0;
+    else if (PyArray_Check(obj) && PyArray_ISBOOL(obj)) {
+        return _nonzero_indices(obj, iter);
+    }
+    else {
+        indtype = PyArray_DescrFromType(PyArray_INTP);
+        arr = PyArray_FromAny(obj, indtype, 0, 0, FORCECAST, NULL);
+        if (arr == NULL) return -1;
+        *iter = (PyArrayIterObject *)PyArray_IterNew(arr);
+        Py_DECREF(arr);
+        if (*iter == NULL) return -1;
+    }
+    return 1;
 }
 
 /* Adjust dimensionality and strides for index object iterators
    --- i.e. broadcast
- */
+*/
 /*OBJECT_API*/
 static int
 PyArray_Broadcast(PyArrayMultiIterObject *mit)
 {
-        int i, nd, k, j;
-        intp tmp;
-        PyArrayIterObject *it;
-
-        /* Discover the broadcast number of dimensions */
-        for (i=0, nd=0; i<mit->numiter; i++)
-                nd = MAX(nd, mit->iters[i]->ao->nd);
-        mit->nd = nd;
-
-        /* Discover the broadcast shape in each dimension */
-        for (i=0; i<nd; i++) {
-                mit->dimensions[i] = 1;
-                for (j=0; j<mit->numiter; j++) {
-                        it = mit->iters[j];
-                        /* This prepends 1 to shapes not already
-                           equal to nd */
-                        k = i + it->ao->nd - nd;
-                        if (k>=0) {
-                                tmp = it->ao->dimensions[k];
-                                if (tmp == 1) continue;
-                                if (mit->dimensions[i] == 1)
-                                        mit->dimensions[i] = tmp;
-                                else if (mit->dimensions[i] != tmp) {
-                                        PyErr_SetString(PyExc_ValueError,
-                                                        "shape mismatch: objects" \
-                                                        " cannot be broadcast" \
-                                                        " to a single shape");
-                                        return -1;
-                                }
-                        }
+    int i, nd, k, j;
+    intp tmp;
+    PyArrayIterObject *it;
+
+    /* Discover the broadcast number of dimensions */
+    for (i=0, nd=0; i<mit->numiter; i++)
+        nd = MAX(nd, mit->iters[i]->ao->nd);
+    mit->nd = nd;
+
+    /* Discover the broadcast shape in each dimension */
+    for (i=0; i<nd; i++) {
+        mit->dimensions[i] = 1;
+        for (j=0; j<mit->numiter; j++) {
+            it = mit->iters[j];
+            /* This prepends 1 to shapes not already
+               equal to nd */
+            k = i + it->ao->nd - nd;
+            if (k>=0) {
+                tmp = it->ao->dimensions[k];
+                if (tmp == 1) continue;
+                if (mit->dimensions[i] == 1)
+                    mit->dimensions[i] = tmp;
+                else if (mit->dimensions[i] != tmp) {
+                    PyErr_SetString(PyExc_ValueError,
+                                    "shape mismatch: objects" \
+                                    " cannot be broadcast" \
+                                    " to a single shape");
+                    return -1;
                 }
+            }
         }
+    }
 
-        /* Reset the iterator dimensions and strides of each iterator
-           object -- using 0 valued strides for broadcasting */
-
-        tmp = PyArray_MultiplyList(mit->dimensions, mit->nd);
-        mit->size = tmp;
-        for (i=0; i<mit->numiter; i++) {
-                it = mit->iters[i];
-                it->nd_m1 = mit->nd - 1;
-                it->size = tmp;
-                nd = it->ao->nd;
-                it->factors[mit->nd-1] = 1;
-                for (j=0; j < mit->nd; j++) {
-                        it->dims_m1[j] = mit->dimensions[j] - 1;
-                        k = j + nd - mit->nd;
-                        /* If this dimension was added or shape
-                           of underlying array was 1 */
-                        if ((k < 0) || \
-                            it->ao->dimensions[k] != mit->dimensions[j]) {
-                                it->contiguous = 0;
-                                it->strides[j] = 0;
-                        }
-                        else {
-                                it->strides[j] = it->ao->strides[k];
-                        }
-                        it->backstrides[j] = it->strides[j] *   \
-                                it->dims_m1[j];
-                        if (j > 0)
-                                it->factors[mit->nd-j-1] =              \
-                                        it->factors[mit->nd-j] *        \
-                                        mit->dimensions[mit->nd-j];
-                }
-                PyArray_ITER_RESET(it);
+    /* Reset the iterator dimensions and strides of each iterator
+       object -- using 0 valued strides for broadcasting */
+
+    tmp = PyArray_MultiplyList(mit->dimensions, mit->nd);
+    mit->size = tmp;
+    for (i=0; i<mit->numiter; i++) {
+        it = mit->iters[i];
+        it->nd_m1 = mit->nd - 1;
+        it->size = tmp;
+        nd = it->ao->nd;
+        it->factors[mit->nd-1] = 1;
+        for (j=0; j < mit->nd; j++) {
+            it->dims_m1[j] = mit->dimensions[j] - 1;
+            k = j + nd - mit->nd;
+            /* If this dimension was added or shape
+               of underlying array was 1 */
+            if ((k < 0) || \
+                it->ao->dimensions[k] != mit->dimensions[j]) {
+                it->contiguous = 0;
+                it->strides[j] = 0;
+            }
+            else {
+                it->strides[j] = it->ao->strides[k];
+            }
+            it->backstrides[j] = it->strides[j] *   \
+                it->dims_m1[j];
+            if (j > 0)
+                it->factors[mit->nd-j-1] =              \
+                    it->factors[mit->nd-j] *        \
+                    mit->dimensions[mit->nd-j];
         }
-        return 0;
+        PyArray_ITER_RESET(it);
+    }
+    return 0;
 }
 
 /* Reset the map iterator to the beginning */
 static void
 PyArray_MapIterReset(PyArrayMapIterObject *mit)
 {
-        int i,j; intp coord[MAX_DIMS];
-        PyArrayIterObject *it;
-        PyArray_CopySwapFunc *copyswap;
+    int i,j; intp coord[MAX_DIMS];
+    PyArrayIterObject *it;
+    PyArray_CopySwapFunc *copyswap;
 
-        mit->index = 0;
+    mit->index = 0;
 
-        copyswap = mit->iters[0]->ao->descr->f->copyswap;
+    copyswap = mit->iters[0]->ao->descr->f->copyswap;
 
-        if (mit->subspace != NULL) {
-                memcpy(coord, mit->bscoord, sizeof(intp)*mit->ait->ao->nd);
-                PyArray_ITER_RESET(mit->subspace);
-                for (i=0; i<mit->numiter; i++) {
-                        it = mit->iters[i];
-                        PyArray_ITER_RESET(it);
-                        j = mit->iteraxes[i];
-                        copyswap(coord+j,it->dataptr,
-                                 !PyArray_ISNOTSWAPPED(it->ao),
-                                 it->ao);
-                }
-                PyArray_ITER_GOTO(mit->ait, coord);
-                mit->subspace->dataptr = mit->ait->dataptr;
-                mit->dataptr = mit->subspace->dataptr;
-        }
-        else {
-                for (i=0; i<mit->numiter; i++) {
-                        it = mit->iters[i];
-                        if (it->size != 0) {
-                                PyArray_ITER_RESET(it);
-                                copyswap(coord+i,it->dataptr,
-                                         !PyArray_ISNOTSWAPPED(it->ao),
-                                         it->ao);
-                        }
-                        else coord[i] = 0;
-                }
-                PyArray_ITER_GOTO(mit->ait, coord);
-                mit->dataptr = mit->ait->dataptr;
+    if (mit->subspace != NULL) {
+        memcpy(coord, mit->bscoord, sizeof(intp)*mit->ait->ao->nd);
+        PyArray_ITER_RESET(mit->subspace);
+        for (i=0; i<mit->numiter; i++) {
+            it = mit->iters[i];
+            PyArray_ITER_RESET(it);
+            j = mit->iteraxes[i];
+            copyswap(coord+j,it->dataptr,
+                     !PyArray_ISNOTSWAPPED(it->ao),
+                     it->ao);
+        }
+        PyArray_ITER_GOTO(mit->ait, coord);
+        mit->subspace->dataptr = mit->ait->dataptr;
+        mit->dataptr = mit->subspace->dataptr;
+    }
+    else {
+        for (i=0; i<mit->numiter; i++) {
+            it = mit->iters[i];
+            if (it->size != 0) {
+                PyArray_ITER_RESET(it);
+                copyswap(coord+i,it->dataptr,
+                         !PyArray_ISNOTSWAPPED(it->ao),
+                         it->ao);
+            }
+            else coord[i] = 0;
         }
-        return;
+        PyArray_ITER_GOTO(mit->ait, coord);
+        mit->dataptr = mit->ait->dataptr;
+    }
+    return;
 }
 
 /* This function needs to update the state of the map iterator
@@ -9879,56 +9878,56 @@ PyArray_MapIterReset(PyArrayMapIterObject *mit)
 static void
 PyArray_MapIterNext(PyArrayMapIterObject *mit)
 {
-        int i, j;
-        intp coord[MAX_DIMS];
-        PyArrayIterObject *it;
-        PyArray_CopySwapFunc *copyswap;
-
-        mit->index += 1;
-        if (mit->index >= mit->size) return;
-        copyswap = mit->iters[0]->ao->descr->f->copyswap;
-        /* Sub-space iteration */
-        if (mit->subspace != NULL) {
-                PyArray_ITER_NEXT(mit->subspace);
-                if (mit->subspace->index >= mit->subspace->size) {
-                        /* reset coord to coordinates of
-                           beginning of the subspace */
-                        memcpy(coord, mit->bscoord,
-                               sizeof(intp)*mit->ait->ao->nd);
-                        PyArray_ITER_RESET(mit->subspace);
-                        for (i=0; i<mit->numiter; i++) {
-                                it = mit->iters[i];
-                                PyArray_ITER_NEXT(it);
-                                j = mit->iteraxes[i];
-                                copyswap(coord+j,it->dataptr,
-                                         !PyArray_ISNOTSWAPPED(it->ao),
-                                         it->ao);
-                        }
-                        PyArray_ITER_GOTO(mit->ait, coord);
-                        mit->subspace->dataptr = mit->ait->dataptr;
-                }
-                mit->dataptr = mit->subspace->dataptr;
-        }
-        else {
-                for (i=0; i<mit->numiter; i++) {
-                        it = mit->iters[i];
-                        PyArray_ITER_NEXT(it);
-                        copyswap(coord+i,it->dataptr,
-                                 !PyArray_ISNOTSWAPPED(it->ao),
-                                 it->ao);
-                }
-                PyArray_ITER_GOTO(mit->ait, coord);
-                mit->dataptr = mit->ait->dataptr;
+    int i, j;
+    intp coord[MAX_DIMS];
+    PyArrayIterObject *it;
+    PyArray_CopySwapFunc *copyswap;
+
+    mit->index += 1;
+    if (mit->index >= mit->size) return;
+    copyswap = mit->iters[0]->ao->descr->f->copyswap;
+    /* Sub-space iteration */
+    if (mit->subspace != NULL) {
+        PyArray_ITER_NEXT(mit->subspace);
+        if (mit->subspace->index >= mit->subspace->size) {
+            /* reset coord to coordinates of
+               beginning of the subspace */
+            memcpy(coord, mit->bscoord,
+                   sizeof(intp)*mit->ait->ao->nd);
+            PyArray_ITER_RESET(mit->subspace);
+            for (i=0; i<mit->numiter; i++) {
+                it = mit->iters[i];
+                PyArray_ITER_NEXT(it);
+                j = mit->iteraxes[i];
+                copyswap(coord+j,it->dataptr,
+                         !PyArray_ISNOTSWAPPED(it->ao),
+                         it->ao);
+            }
+            PyArray_ITER_GOTO(mit->ait, coord);
+            mit->subspace->dataptr = mit->ait->dataptr;
         }
-        return;
+        mit->dataptr = mit->subspace->dataptr;
+    }
+    else {
+        for (i=0; i<mit->numiter; i++) {
+            it = mit->iters[i];
+            PyArray_ITER_NEXT(it);
+            copyswap(coord+i,it->dataptr,
+                     !PyArray_ISNOTSWAPPED(it->ao),
+                     it->ao);
+        }
+        PyArray_ITER_GOTO(mit->ait, coord);
+        mit->dataptr = mit->ait->dataptr;
+    }
+    return;
 }
 
 /*  Bind a mapiteration to a particular array */
 
 /*  Determine if subspace iteration is necessary.  If so,
-         1) Fill in mit->iteraxes
-         2) Create subspace iterator
-         3) Update nd, dimensions, and size.
+    1) Fill in mit->iteraxes
+    2) Create subspace iterator
+    3) Update nd, dimensions, and size.
 
     Subspace iteration is necessary if:  arr->nd > mit->numiter
 */
@@ -9941,146 +9940,146 @@ PyArray_MapIterNext(PyArrayMapIterObject *mit)
 static void
 PyArray_MapIterBind(PyArrayMapIterObject *mit, PyArrayObject *arr)
 {
-        int subnd;
-        PyObject *sub, *obj=NULL;
-        int i, j, n, curraxis, ellipexp, noellip;
-        PyArrayIterObject *it;
-        intp dimsize;
-        intp *indptr;
+    int subnd;
+    PyObject *sub, *obj=NULL;
+    int i, j, n, curraxis, ellipexp, noellip;
+    PyArrayIterObject *it;
+    intp dimsize;
+    intp *indptr;
 
-        subnd = arr->nd - mit->numiter;
-        if (subnd < 0) {
-                PyErr_SetString(PyExc_ValueError,
-                                "too many indices for array");
-                return;
-        }
-
-        mit->ait = (PyArrayIterObject *)PyArray_IterNew((PyObject *)arr);
-        if (mit->ait == NULL) return;
+    subnd = arr->nd - mit->numiter;
+    if (subnd < 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "too many indices for array");
+        return;
+    }
 
-        /* no subspace iteration needed.  Finish up and Return */
-        if (subnd == 0) {
-                n = arr->nd;
-                for (i=0; i<n; i++) {
-                        mit->iteraxes[i] = i;
-                }
-                goto finish;
-        }
+    mit->ait = (PyArrayIterObject *)PyArray_IterNew((PyObject *)arr);
+    if (mit->ait == NULL) return;
 
-        /* all indexing arrays have been converted to 0
-           therefore we can extract the subspace with a simple
-           getitem call which will use view semantics
-        */
-        /* But, be sure to do it with a true array.
-         */
-        if (PyArray_CheckExact(arr)) {
-                sub = array_subscript_simple(arr, mit->indexobj);
-        }
-        else {
-                Py_INCREF(arr);
-                obj = PyArray_EnsureArray((PyObject *)arr);
-                if (obj == NULL) goto fail;
-                sub = array_subscript_simple((PyArrayObject *)obj, mit->indexobj);
-                Py_DECREF(obj);
+    /* no subspace iteration needed.  Finish up and Return */
+    if (subnd == 0) {
+        n = arr->nd;
+        for (i=0; i<n; i++) {
+            mit->iteraxes[i] = i;
         }
+        goto finish;
+    }
 
-        if (sub == NULL) goto fail;
-        mit->subspace = (PyArrayIterObject *)PyArray_IterNew(sub);
-        Py_DECREF(sub);
-        if (mit->subspace == NULL) goto fail;
-
-        /* Expand dimensions of result */
-        n = mit->subspace->ao->nd;
-        for (i=0; i<n; i++)
-                mit->dimensions[mit->nd+i] = mit->subspace->ao->dimensions[i];
-        mit->nd += n;
-
-        /* Now, we still need to interpret the ellipsis and slice objects
-           to determine which axes the indexing arrays are referring to
-        */
-        n = PyTuple_GET_SIZE(mit->indexobj);
+    /* all indexing arrays have been converted to 0
+       therefore we can extract the subspace with a simple
+       getitem call which will use view semantics
+    */
+    /* But, be sure to do it with a true array.
+     */
+    if (PyArray_CheckExact(arr)) {
+        sub = array_subscript_simple(arr, mit->indexobj);
+    }
+    else {
+        Py_INCREF(arr);
+        obj = PyArray_EnsureArray((PyObject *)arr);
+        if (obj == NULL) goto fail;
+        sub = array_subscript_simple((PyArrayObject *)obj, mit->indexobj);
+        Py_DECREF(obj);
+    }
 
-        /* The number of dimensions an ellipsis takes up */
-        ellipexp = arr->nd - n + 1;
-        /* Now fill in iteraxes -- remember indexing arrays have been
-           converted to 0's in mit->indexobj */
-        curraxis = 0;
-        j = 0;
-        noellip = 1;  /* Only expand the first ellipsis */
-        memset(mit->bscoord, 0, sizeof(intp)*arr->nd);
-        for (i=0; i<n; i++) {
-                /* We need to fill in the starting coordinates for
-                   the subspace */
-                obj = PyTuple_GET_ITEM(mit->indexobj, i);
-                if (PyInt_Check(obj) || PyLong_Check(obj))
-                        mit->iteraxes[j++] = curraxis++;
-                else if (noellip && obj == Py_Ellipsis) {
-                        curraxis += ellipexp;
-                        noellip = 0;
-                }
-                else {
-                        intp start=0;
-                        intp stop, step;
-                        /* Should be slice object or
-                           another Ellipsis */
-                        if (obj == Py_Ellipsis) {
-                                mit->bscoord[curraxis] = 0;
-                        }
-                        else if (!PySlice_Check(obj) || \
-                                 (slice_GetIndices((PySliceObject *)obj,
-                                                   arr->dimensions[curraxis],
-                                                   &start, &stop, &step,
-                                                   &dimsize) < 0)) {
-                                PyErr_Format(PyExc_ValueError,
-                                             "unexpected object "       \
-                                             "(%s) in selection position %d",
-                                             obj->ob_type->tp_name, i);
-                                goto fail;
-                        }
-                        else {
-                                mit->bscoord[curraxis] = start;
-                        }
-                        curraxis += 1;
-                }
+    if (sub == NULL) goto fail;
+    mit->subspace = (PyArrayIterObject *)PyArray_IterNew(sub);
+    Py_DECREF(sub);
+    if (mit->subspace == NULL) goto fail;
+
+    /* Expand dimensions of result */
+    n = mit->subspace->ao->nd;
+    for (i=0; i<n; i++)
+        mit->dimensions[mit->nd+i] = mit->subspace->ao->dimensions[i];
+    mit->nd += n;
+
+    /* Now, we still need to interpret the ellipsis and slice objects
+       to determine which axes the indexing arrays are referring to
+    */
+    n = PyTuple_GET_SIZE(mit->indexobj);
+
+    /* The number of dimensions an ellipsis takes up */
+    ellipexp = arr->nd - n + 1;
+    /* Now fill in iteraxes -- remember indexing arrays have been
+       converted to 0's in mit->indexobj */
+    curraxis = 0;
+    j = 0;
+    noellip = 1;  /* Only expand the first ellipsis */
+    memset(mit->bscoord, 0, sizeof(intp)*arr->nd);
+    for (i=0; i<n; i++) {
+        /* We need to fill in the starting coordinates for
+           the subspace */
+        obj = PyTuple_GET_ITEM(mit->indexobj, i);
+        if (PyInt_Check(obj) || PyLong_Check(obj))
+            mit->iteraxes[j++] = curraxis++;
+        else if (noellip && obj == Py_Ellipsis) {
+            curraxis += ellipexp;
+            noellip = 0;
         }
- finish:
-        /* Here check the indexes (now that we have iteraxes) */
-        mit->size = PyArray_MultiplyList(mit->dimensions, mit->nd);
-        if (mit->ait->size == 0 && mit->size != 0) {
-                PyErr_SetString(PyExc_ValueError,
-                                "invalid index into a 0-size array");
+        else {
+            intp start=0;
+            intp stop, step;
+            /* Should be slice object or
+               another Ellipsis */
+            if (obj == Py_Ellipsis) {
+                mit->bscoord[curraxis] = 0;
+            }
+            else if (!PySlice_Check(obj) || \
+                     (slice_GetIndices((PySliceObject *)obj,
+                                       arr->dimensions[curraxis],
+                                       &start, &stop, &step,
+                                       &dimsize) < 0)) {
+                PyErr_Format(PyExc_ValueError,
+                             "unexpected object "       \
+                             "(%s) in selection position %d",
+                             obj->ob_type->tp_name, i);
                 goto fail;
+            }
+            else {
+                mit->bscoord[curraxis] = start;
+            }
+            curraxis += 1;
         }
+    }
+ finish:
+    /* Here check the indexes (now that we have iteraxes) */
+    mit->size = PyArray_MultiplyList(mit->dimensions, mit->nd);
+    if (mit->ait->size == 0 && mit->size != 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "invalid index into a 0-size array");
+        goto fail;
+    }
 
-        for (i=0; i<mit->numiter; i++) {
-                intp indval;
-                it = mit->iters[i];
-                PyArray_ITER_RESET(it);
-                dimsize = arr->dimensions[mit->iteraxes[i]];
-                while(it->index < it->size) {
-                        indptr = ((intp *)it->dataptr);
-                        indval = *indptr;
-                        if (indval < 0) indval += dimsize;
-                        if (indval < 0 || indval >= dimsize) {
-                                PyErr_Format(PyExc_IndexError,
-                                             "index (%d) out of range "\
-                                             "(0<=index<=%d) in dimension %d",
-                                             (int) indval, (int) (dimsize-1),
-                                             mit->iteraxes[i]);
-                                goto fail;
-                        }
-                        PyArray_ITER_NEXT(it);
-                }
-                PyArray_ITER_RESET(it);
+    for (i=0; i<mit->numiter; i++) {
+        intp indval;
+        it = mit->iters[i];
+        PyArray_ITER_RESET(it);
+        dimsize = arr->dimensions[mit->iteraxes[i]];
+        while(it->index < it->size) {
+            indptr = ((intp *)it->dataptr);
+            indval = *indptr;
+            if (indval < 0) indval += dimsize;
+            if (indval < 0 || indval >= dimsize) {
+                PyErr_Format(PyExc_IndexError,
+                             "index (%d) out of range "\
+                             "(0<=index<=%d) in dimension %d",
+                             (int) indval, (int) (dimsize-1),
+                             mit->iteraxes[i]);
+                goto fail;
+            }
+            PyArray_ITER_NEXT(it);
         }
-        return;
+        PyArray_ITER_RESET(it);
+    }
+    return;
 
  fail:
-        Py_XDECREF(mit->subspace);
-        Py_XDECREF(mit->ait);
-        mit->subspace = NULL;
-        mit->ait = NULL;
-        return;
+    Py_XDECREF(mit->subspace);
+    Py_XDECREF(mit->ait);
+    mit->subspace = NULL;
+    mit->ait = NULL;
+    return;
 }
 
 /* This function takes a Boolean array and constructs index objects and
@@ -10089,119 +10088,119 @@ PyArray_MapIterBind(PyArrayMapIterObject *mit, PyArrayObject *arr)
 static int
 _nonzero_indices(PyObject *myBool, PyArrayIterObject **iters)
 {
-        PyArray_Descr *typecode;
-        PyArrayObject *ba =NULL, *new=NULL;
-        int nd, j;
-        intp size, i, count;
-        Bool *ptr;
-        intp coords[MAX_DIMS], dims_m1[MAX_DIMS];
-        intp *dptr[MAX_DIMS];
-
-        typecode=PyArray_DescrFromType(PyArray_BOOL);
-        ba = (PyArrayObject *)PyArray_FromAny(myBool, typecode, 0, 0,
-                                              CARRAY, NULL);
-        if (ba == NULL) return -1;
-        nd = ba->nd;
-        for (j=0; j<nd; j++) iters[j] = NULL;
-        size = PyArray_SIZE(ba);
-        ptr = (Bool *)ba->data;
-        count = 0;
-
-        /* pre-determine how many nonzero entries there are */
-        for (i=0; i<size; i++)
-                if (*(ptr++)) count++;
-
-        /* create count-sized index arrays for each dimension */
-        for (j=0; j<nd; j++) {
-                new = (PyArrayObject *)PyArray_New(&PyArray_Type, 1, &count,
-                                                   PyArray_INTP, NULL, NULL,
-                                                   0, 0, NULL);
-                if (new == NULL) goto fail;
-                iters[j] = (PyArrayIterObject *)        \
-                        PyArray_IterNew((PyObject *)new);
-                Py_DECREF(new);
-                if (iters[j] == NULL) goto fail;
-                dptr[j] = (intp *)iters[j]->ao->data;
-                coords[j] = 0;
-                dims_m1[j] = ba->dimensions[j]-1;
-        }
+    PyArray_Descr *typecode;
+    PyArrayObject *ba =NULL, *new=NULL;
+    int nd, j;
+    intp size, i, count;
+    Bool *ptr;
+    intp coords[MAX_DIMS], dims_m1[MAX_DIMS];
+    intp *dptr[MAX_DIMS];
+
+    typecode=PyArray_DescrFromType(PyArray_BOOL);
+    ba = (PyArrayObject *)PyArray_FromAny(myBool, typecode, 0, 0,
+                                          CARRAY, NULL);
+    if (ba == NULL) return -1;
+    nd = ba->nd;
+    for (j=0; j<nd; j++) iters[j] = NULL;
+    size = PyArray_SIZE(ba);
+    ptr = (Bool *)ba->data;
+    count = 0;
+
+    /* pre-determine how many nonzero entries there are */
+    for (i=0; i<size; i++)
+        if (*(ptr++)) count++;
+
+    /* create count-sized index arrays for each dimension */
+    for (j=0; j<nd; j++) {
+        new = (PyArrayObject *)PyArray_New(&PyArray_Type, 1, &count,
+                                           PyArray_INTP, NULL, NULL,
+                                           0, 0, NULL);
+        if (new == NULL) goto fail;
+        iters[j] = (PyArrayIterObject *)        \
+            PyArray_IterNew((PyObject *)new);
+        Py_DECREF(new);
+        if (iters[j] == NULL) goto fail;
+        dptr[j] = (intp *)iters[j]->ao->data;
+        coords[j] = 0;
+        dims_m1[j] = ba->dimensions[j]-1;
+    }
 
-        ptr = (Bool *)ba->data;
+    ptr = (Bool *)ba->data;
 
-        if (count == 0) goto finish;
+    if (count == 0) goto finish;
 
-        /* Loop through the Boolean array  and copy coordinates
-           for non-zero entries */
-        for (i=0; i<size; i++) {
-                if (*(ptr++)) {
-                        for (j=0; j<nd; j++)
-                                *(dptr[j]++) = coords[j];
-                }
-                /* Borrowed from ITER_NEXT macro */
-                for (j=nd-1; j>=0; j--) {
-                        if (coords[j] < dims_m1[j]) {
-                                coords[j]++;
-                                break;
-                        }
-                        else {
-                                coords[j] = 0;
-                        }
-                }
+    /* Loop through the Boolean array  and copy coordinates
+       for non-zero entries */
+    for (i=0; i<size; i++) {
+        if (*(ptr++)) {
+            for (j=0; j<nd; j++)
+                *(dptr[j]++) = coords[j];
+        }
+        /* Borrowed from ITER_NEXT macro */
+        for (j=nd-1; j>=0; j--) {
+            if (coords[j] < dims_m1[j]) {
+                coords[j]++;
+                break;
+            }
+            else {
+                coords[j] = 0;
+            }
         }
+    }
 
  finish:
-        Py_DECREF(ba);
-        return nd;
+    Py_DECREF(ba);
+    return nd;
 
  fail:
-        for (j=0; j<nd; j++) {
-                Py_XDECREF(iters[j]);
-        }
-        Py_XDECREF(ba);
-        return -1;
+    for (j=0; j<nd; j++) {
+        Py_XDECREF(iters[j]);
+    }
+    Py_XDECREF(ba);
+    return -1;
 }
 
 static PyObject *
 PyArray_MapIterNew(PyObject *indexobj, int oned, int fancy)
 {
-        PyArrayMapIterObject *mit;
-        PyArray_Descr *indtype;
-        PyObject *arr = NULL;
-        int i, n, started, nonindex;
+    PyArrayMapIterObject *mit;
+    PyArray_Descr *indtype;
+    PyObject *arr = NULL;
+    int i, n, started, nonindex;
 
-        if (fancy == SOBJ_BADARRAY) {
-                PyErr_SetString(PyExc_IndexError,                       \
-                                "arrays used as indices must be of "    \
-                                "integer (or boolean) type");
-                return NULL;
-        }
-        if (fancy == SOBJ_TOOMANY) {
-                PyErr_SetString(PyExc_IndexError, "too many indices");
-                return NULL;
-        }
+    if (fancy == SOBJ_BADARRAY) {
+        PyErr_SetString(PyExc_IndexError,                       \
+                        "arrays used as indices must be of "    \
+                        "integer (or boolean) type");
+        return NULL;
+    }
+    if (fancy == SOBJ_TOOMANY) {
+        PyErr_SetString(PyExc_IndexError, "too many indices");
+        return NULL;
+    }
 
-        mit = (PyArrayMapIterObject *)_pya_malloc(sizeof(PyArrayMapIterObject));
-        PyObject_Init((PyObject *)mit, &PyArrayMapIter_Type);
-        if (mit == NULL)
-                return NULL;
-        for (i=0; i<MAX_DIMS; i++)
-                mit->iters[i] = NULL;
-        mit->index = 0;
-        mit->ait = NULL;
-        mit->subspace = NULL;
-        mit->numiter = 0;
-        mit->consec = 1;
-        Py_INCREF(indexobj);
+    mit = (PyArrayMapIterObject *)_pya_malloc(sizeof(PyArrayMapIterObject));
+    PyObject_Init((PyObject *)mit, &PyArrayMapIter_Type);
+    if (mit == NULL)
+        return NULL;
+    for (i=0; i<MAX_DIMS; i++)
+        mit->iters[i] = NULL;
+    mit->index = 0;
+    mit->ait = NULL;
+    mit->subspace = NULL;
+    mit->numiter = 0;
+    mit->consec = 1;
+    Py_INCREF(indexobj);
+    mit->indexobj = indexobj;
+
+    if (fancy == SOBJ_LISTTUP) {
+        PyObject *newobj;
+        newobj = PySequence_Tuple(indexobj);
+        if (newobj == NULL) goto fail;
+        Py_DECREF(indexobj);
+        indexobj = newobj;
         mit->indexobj = indexobj;
-
-        if (fancy == SOBJ_LISTTUP) {
-                PyObject *newobj;
-                newobj = PySequence_Tuple(indexobj);
-                if (newobj == NULL) goto fail;
-                Py_DECREF(indexobj);
-                indexobj = newobj;
-                mit->indexobj = indexobj;
-        }
+    }
 
 #undef SOBJ_NOTFANCY
 #undef SOBJ_ISFANCY
@@ -10209,118 +10208,118 @@ PyArray_MapIterNew(PyObject *indexobj, int oned, int fancy)
 #undef SOBJ_TOOMANY
 #undef SOBJ_LISTTUP
 
-        if (oned) return (PyObject *)mit;
-
-        /* Must have some kind of fancy indexing if we are here */
-        /* indexobj is either a list, an arrayobject, or a tuple
-           (with at least 1 list or arrayobject or Bool object), */
-
-        /* convert all inputs to iterators */
-        if (PyArray_Check(indexobj) &&                  \
-            (PyArray_TYPE(indexobj) == PyArray_BOOL)) {
-                mit->numiter = _nonzero_indices(indexobj, mit->iters);
-                if (mit->numiter < 0) goto fail;
-                mit->nd = 1;
-                mit->dimensions[0] = mit->iters[0]->dims_m1[0]+1;
-                Py_DECREF(mit->indexobj);
-                mit->indexobj = PyTuple_New(mit->numiter);
-                if (mit->indexobj == NULL) goto fail;
-                for (i=0; i<mit->numiter; i++) {
-                        PyTuple_SET_ITEM(mit->indexobj, i,
-                                         PyInt_FromLong(0));
-                }
+    if (oned) return (PyObject *)mit;
+
+    /* Must have some kind of fancy indexing if we are here */
+    /* indexobj is either a list, an arrayobject, or a tuple
+       (with at least 1 list or arrayobject or Bool object), */
+
+    /* convert all inputs to iterators */
+    if (PyArray_Check(indexobj) &&                  \
+        (PyArray_TYPE(indexobj) == PyArray_BOOL)) {
+        mit->numiter = _nonzero_indices(indexobj, mit->iters);
+        if (mit->numiter < 0) goto fail;
+        mit->nd = 1;
+        mit->dimensions[0] = mit->iters[0]->dims_m1[0]+1;
+        Py_DECREF(mit->indexobj);
+        mit->indexobj = PyTuple_New(mit->numiter);
+        if (mit->indexobj == NULL) goto fail;
+        for (i=0; i<mit->numiter; i++) {
+            PyTuple_SET_ITEM(mit->indexobj, i,
+                             PyInt_FromLong(0));
         }
+    }
 
-        else if (PyArray_Check(indexobj) || !PyTuple_Check(indexobj)) {
-                mit->numiter = 1;
-                indtype = PyArray_DescrFromType(PyArray_INTP);
-                arr = PyArray_FromAny(indexobj, indtype, 0, 0, FORCECAST, NULL);
-                if (arr == NULL) goto fail;
-                mit->iters[0] = (PyArrayIterObject *)PyArray_IterNew(arr);
-                if (mit->iters[0] == NULL) {Py_DECREF(arr); goto fail;}
-                mit->nd = PyArray_NDIM(arr);
-                memcpy(mit->dimensions,PyArray_DIMS(arr),mit->nd*sizeof(intp));
-                mit->size = PyArray_SIZE(arr);
-                Py_DECREF(arr);
-                Py_DECREF(mit->indexobj);
-                mit->indexobj = Py_BuildValue("(N)", PyInt_FromLong(0));
-        }
-        else { /* must be a tuple */
-                PyObject *obj;
-                PyArrayIterObject **iterp;
-                PyObject *new;
-                int numiters, j, n2;
-                /* Make a copy of the tuple -- we will be replacing
-                    index objects with 0's */
-                n = PyTuple_GET_SIZE(indexobj);
-                n2 = n;
-                new = PyTuple_New(n2);
-                if (new == NULL) goto fail;
-                started = 0;
-                nonindex = 0;
-                j = 0;
-                for (i=0; i<n; i++) {
-                        obj = PyTuple_GET_ITEM(indexobj,i);
-                        iterp = mit->iters + mit->numiter;
-                        if ((numiters=_convert_obj(obj, iterp)) < 0) {
-                                Py_DECREF(new);
-                                goto fail;
-                        }
-                        if (numiters > 0) {
-                                started = 1;
-                                if (nonindex) mit->consec = 0;
-                                mit->numiter += numiters;
-                                if (numiters == 1) {
-                                        PyTuple_SET_ITEM(new,j++,
-                                                         PyInt_FromLong(0));
-                                }
-                                else { /* we need to grow the
-                                          new indexing object and fill
-                                          it with 0s for each of the iterators
-                                          produced */
-                                        int k;
-                                        n2 += numiters - 1;
-                                        if (_PyTuple_Resize(&new, n2) < 0)
-                                                goto fail;
-                                        for (k=0;k<numiters;k++) {
-                                                PyTuple_SET_ITEM        \
-                                                        (new,j++,
-                                                         PyInt_FromLong(0));
-                                        }
-                                }
-                        }
-                        else {
-                                if (started) nonindex = 1;
-                                Py_INCREF(obj);
-                                PyTuple_SET_ITEM(new,j++,obj);
-                        }
-                }
-                Py_DECREF(mit->indexobj);
-                mit->indexobj = new;
-                /* Store the number of iterators actually converted */
-                /*  These will be mapped to actual axes at bind time */
-                if (PyArray_Broadcast((PyArrayMultiIterObject *)mit) < 0)
+    else if (PyArray_Check(indexobj) || !PyTuple_Check(indexobj)) {
+        mit->numiter = 1;
+        indtype = PyArray_DescrFromType(PyArray_INTP);
+        arr = PyArray_FromAny(indexobj, indtype, 0, 0, FORCECAST, NULL);
+        if (arr == NULL) goto fail;
+        mit->iters[0] = (PyArrayIterObject *)PyArray_IterNew(arr);
+        if (mit->iters[0] == NULL) {Py_DECREF(arr); goto fail;}
+        mit->nd = PyArray_NDIM(arr);
+        memcpy(mit->dimensions,PyArray_DIMS(arr),mit->nd*sizeof(intp));
+        mit->size = PyArray_SIZE(arr);
+        Py_DECREF(arr);
+        Py_DECREF(mit->indexobj);
+        mit->indexobj = Py_BuildValue("(N)", PyInt_FromLong(0));
+    }
+    else { /* must be a tuple */
+        PyObject *obj;
+        PyArrayIterObject **iterp;
+        PyObject *new;
+        int numiters, j, n2;
+        /* Make a copy of the tuple -- we will be replacing
+           index objects with 0's */
+        n = PyTuple_GET_SIZE(indexobj);
+        n2 = n;
+        new = PyTuple_New(n2);
+        if (new == NULL) goto fail;
+        started = 0;
+        nonindex = 0;
+        j = 0;
+        for (i=0; i<n; i++) {
+            obj = PyTuple_GET_ITEM(indexobj,i);
+            iterp = mit->iters + mit->numiter;
+            if ((numiters=_convert_obj(obj, iterp)) < 0) {
+                Py_DECREF(new);
+                goto fail;
+            }
+            if (numiters > 0) {
+                started = 1;
+                if (nonindex) mit->consec = 0;
+                mit->numiter += numiters;
+                if (numiters == 1) {
+                    PyTuple_SET_ITEM(new,j++,
+                                     PyInt_FromLong(0));
+                }
+                else { /* we need to grow the
+                          new indexing object and fill
+                          it with 0s for each of the iterators
+                          produced */
+                    int k;
+                    n2 += numiters - 1;
+                    if (_PyTuple_Resize(&new, n2) < 0)
                         goto fail;
+                    for (k=0;k<numiters;k++) {
+                        PyTuple_SET_ITEM        \
+                            (new,j++,
+                             PyInt_FromLong(0));
+                    }
+                }
+            }
+            else {
+                if (started) nonindex = 1;
+                Py_INCREF(obj);
+                PyTuple_SET_ITEM(new,j++,obj);
+            }
         }
+        Py_DECREF(mit->indexobj);
+        mit->indexobj = new;
+        /* Store the number of iterators actually converted */
+        /*  These will be mapped to actual axes at bind time */
+        if (PyArray_Broadcast((PyArrayMultiIterObject *)mit) < 0)
+            goto fail;
+    }
 
-        return (PyObject *)mit;
+    return (PyObject *)mit;
 
  fail:
-        Py_DECREF(mit);
-        return NULL;
+    Py_DECREF(mit);
+    return NULL;
 }
 
 
 static void
 arraymapiter_dealloc(PyArrayMapIterObject *mit)
 {
-        int i;
-        Py_XDECREF(mit->indexobj);
-        Py_XDECREF(mit->ait);
-        Py_XDECREF(mit->subspace);
-        for (i=0; i<mit->numiter; i++)
-                Py_XDECREF(mit->iters[i]);
-        _pya_free(mit);
+    int i;
+    Py_XDECREF(mit->indexobj);
+    Py_XDECREF(mit->ait);
+    Py_XDECREF(mit->subspace);
+    for (i=0; i<mit->numiter; i++)
+        Py_XDECREF(mit->iters[i]);
+    _pya_free(mit);
 }
 
 /* The mapiter object must be created new each time.  It does not work
@@ -10335,53 +10334,53 @@ arraymapiter_dealloc(PyArrayMapIterObject *mit)
 */
 
 static PyTypeObject PyArrayMapIter_Type = {
-        PyObject_HEAD_INIT(NULL)
-        0,                                       /* ob_size */
-        "numpy.mapiter",                        /* tp_name */
-        sizeof(PyArrayIterObject),               /* tp_basicsize */
-        0,                                       /* tp_itemsize */
-        /* methods */
-        (destructor)arraymapiter_dealloc,       /* tp_dealloc */
-        0,                                      /* tp_print */
-        0,                                      /* tp_getattr */
-        0,                                      /* tp_setattr */
-        0,                                      /* tp_compare */
-        0,                                      /* tp_repr */
-        0,                                      /* tp_as_number */
-        0,                                      /* tp_as_sequence */
-        0,                                      /* tp_as_mapping */
-        0,                                      /* tp_hash */
-        0,                                      /* tp_call */
-        0,                                      /* tp_str */
-        0,              /* tp_getattro */
-        0,                                      /* tp_setattro */
-        0,                                      /* tp_as_buffer */
-        Py_TPFLAGS_DEFAULT,                     /* tp_flags */
-        0,                                      /* tp_doc */
-        (traverseproc)0,                        /* tp_traverse */
-        0,                                      /* tp_clear */
-        0,                                      /* tp_richcompare */
-        0,                                      /* tp_weaklistoffset */
-        0,                                      /* tp_iter */
-        (iternextfunc)0,                        /* tp_iternext */
-        0,                              /* tp_methods */
-        0,                                        /* tp_members */
-        0,                                        /* tp_getset */
-        0,                                        /* tp_base */
-        0,                                        /* tp_dict */
-        0,                                        /* tp_descr_get */
-        0,                                        /* tp_descr_set */
-        0,                                        /* tp_dictoffset */
-        (initproc)0,                              /* tp_init */
-        0,                                        /* tp_alloc */
-        0,                                        /* tp_new */
-        0,                                        /* tp_free */
-        0,                                        /* tp_is_gc */
-        0,                                        /* tp_bases */
-        0,                                        /* tp_mro */
-        0,                                        /* tp_cache */
-        0,                                        /* tp_subclasses */
-        0                                         /* tp_weaklist */
+    PyObject_HEAD_INIT(NULL)
+    0,                                       /* ob_size */
+    "numpy.mapiter",                        /* tp_name */
+    sizeof(PyArrayIterObject),               /* tp_basicsize */
+    0,                                       /* tp_itemsize */
+    /* methods */
+    (destructor)arraymapiter_dealloc,       /* tp_dealloc */
+    0,                                      /* tp_print */
+    0,                                      /* tp_getattr */
+    0,                                      /* tp_setattr */
+    0,                                      /* tp_compare */
+    0,                                      /* tp_repr */
+    0,                                      /* tp_as_number */
+    0,                                      /* tp_as_sequence */
+    0,                                      /* tp_as_mapping */
+    0,                                      /* tp_hash */
+    0,                                      /* tp_call */
+    0,                                      /* tp_str */
+    0,              /* tp_getattro */
+    0,                                      /* tp_setattro */
+    0,                                      /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                     /* tp_flags */
+    0,                                      /* tp_doc */
+    (traverseproc)0,                        /* tp_traverse */
+    0,                                      /* tp_clear */
+    0,                                      /* tp_richcompare */
+    0,                                      /* tp_weaklistoffset */
+    0,                                      /* tp_iter */
+    (iternextfunc)0,                        /* tp_iternext */
+    0,                              /* tp_methods */
+    0,                                        /* tp_members */
+    0,                                        /* tp_getset */
+    0,                                        /* tp_base */
+    0,                                        /* tp_dict */
+    0,                                        /* tp_descr_get */
+    0,                                        /* tp_descr_set */
+    0,                                        /* tp_dictoffset */
+    (initproc)0,                              /* tp_init */
+    0,                                        /* tp_alloc */
+    0,                                        /* tp_new */
+    0,                                        /* tp_free */
+    0,                                        /* tp_is_gc */
+    0,                                        /* tp_bases */
+    0,                                        /* tp_mro */
+    0,                                        /* tp_cache */
+    0,                                        /* tp_subclasses */
+    0                                         /* tp_weaklist */
 
 };
 
@@ -10389,152 +10388,152 @@ static PyTypeObject PyArrayMapIter_Type = {
 
 
 /*OBJECT_API
- Get MultiIterator,
+  Get MultiIterator,
 */
 static PyObject *
 PyArray_MultiIterNew(int n, ...)
 {
-        va_list va;
-        PyArrayMultiIterObject *multi;
-        PyObject *current;
-        PyObject *arr;
+    va_list va;
+    PyArrayMultiIterObject *multi;
+    PyObject *current;
+    PyObject *arr;
 
-        int i, err=0;
+    int i, err=0;
 
-        if (n < 2 || n > NPY_MAXARGS) {
-                PyErr_Format(PyExc_ValueError,
-                             "Need between 2 and (%d) "                 \
-                             "array objects (inclusive).", NPY_MAXARGS);
-                return NULL;
-        }
+    if (n < 2 || n > NPY_MAXARGS) {
+        PyErr_Format(PyExc_ValueError,
+                     "Need between 2 and (%d) "                 \
+                     "array objects (inclusive).", NPY_MAXARGS);
+        return NULL;
+    }
 
-        /* fprintf(stderr, "multi new...");*/
+    /* fprintf(stderr, "multi new...");*/
 
-        multi = _pya_malloc(sizeof(PyArrayMultiIterObject));
-        if (multi == NULL) return PyErr_NoMemory();
-        PyObject_Init((PyObject *)multi, &PyArrayMultiIter_Type);
+    multi = _pya_malloc(sizeof(PyArrayMultiIterObject));
+    if (multi == NULL) return PyErr_NoMemory();
+    PyObject_Init((PyObject *)multi, &PyArrayMultiIter_Type);
 
-        for (i=0; i<n; i++) multi->iters[i] = NULL;
-        multi->numiter = n;
-        multi->index = 0;
+    for (i=0; i<n; i++) multi->iters[i] = NULL;
+    multi->numiter = n;
+    multi->index = 0;
 
-        va_start(va, n);
-        for (i=0; i<n; i++) {
-                current = va_arg(va, PyObject *);
-                arr = PyArray_FROM_O(current);
-                if (arr==NULL) {
-                        err=1; break;
-                }
-                else {
-                        multi->iters[i] = (PyArrayIterObject *)PyArray_IterNew(arr);
-                        Py_DECREF(arr);
-                }
+    va_start(va, n);
+    for (i=0; i<n; i++) {
+        current = va_arg(va, PyObject *);
+        arr = PyArray_FROM_O(current);
+        if (arr==NULL) {
+            err=1; break;
+        }
+        else {
+            multi->iters[i] = (PyArrayIterObject *)PyArray_IterNew(arr);
+            Py_DECREF(arr);
         }
+    }
 
-        va_end(va);
+    va_end(va);
 
-        if (!err && PyArray_Broadcast(multi) < 0) err=1;
+    if (!err && PyArray_Broadcast(multi) < 0) err=1;
 
-        if (err) {
-                Py_DECREF(multi);
-                return NULL;
-        }
+    if (err) {
+        Py_DECREF(multi);
+        return NULL;
+    }
 
-        PyArray_MultiIter_RESET(multi);
+    PyArray_MultiIter_RESET(multi);
 
-        return (PyObject *)multi;
+    return (PyObject *)multi;
 }
 
 static PyObject *
 arraymultiter_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
 {
 
-        int n, i;
-        PyArrayMultiIterObject *multi;
-        PyObject *arr;
+    int n, i;
+    PyArrayMultiIterObject *multi;
+    PyObject *arr;
 
-        if (kwds != NULL) {
-                PyErr_SetString(PyExc_ValueError,
-                                "keyword arguments not accepted.");
-                return NULL;
-        }
-
-        n = PyTuple_Size(args);
-        if (n < 2 || n > NPY_MAXARGS) {
-                if (PyErr_Occurred()) return NULL;
-                PyErr_Format(PyExc_ValueError,
-                             "Need at least two and fewer than (%d) "   \
-                             "array objects.", NPY_MAXARGS);
-                return NULL;
-        }
+    if (kwds != NULL) {
+        PyErr_SetString(PyExc_ValueError,
+                        "keyword arguments not accepted.");
+        return NULL;
+    }
 
-        multi = _pya_malloc(sizeof(PyArrayMultiIterObject));
-        if (multi == NULL) return PyErr_NoMemory();
-        PyObject_Init((PyObject *)multi, &PyArrayMultiIter_Type);
+    n = PyTuple_Size(args);
+    if (n < 2 || n > NPY_MAXARGS) {
+        if (PyErr_Occurred()) return NULL;
+        PyErr_Format(PyExc_ValueError,
+                     "Need at least two and fewer than (%d) "   \
+                     "array objects.", NPY_MAXARGS);
+        return NULL;
+    }
 
-        multi->numiter = n;
-        multi->index = 0;
-        for (i=0; i<n; i++) multi->iters[i] = NULL;
-        for (i=0; i<n; i++) {
-                arr = PyArray_FromAny(PyTuple_GET_ITEM(args, i), NULL, 0, 0, 0, NULL);
-                if (arr == NULL) goto fail;
-                if ((multi->iters[i] =                                  \
-                     (PyArrayIterObject *)PyArray_IterNew(arr))==NULL)
-                        goto fail;
-                Py_DECREF(arr);
-        }
-        if (PyArray_Broadcast(multi) < 0) goto fail;
-        PyArray_MultiIter_RESET(multi);
+    multi = _pya_malloc(sizeof(PyArrayMultiIterObject));
+    if (multi == NULL) return PyErr_NoMemory();
+    PyObject_Init((PyObject *)multi, &PyArrayMultiIter_Type);
+
+    multi->numiter = n;
+    multi->index = 0;
+    for (i=0; i<n; i++) multi->iters[i] = NULL;
+    for (i=0; i<n; i++) {
+        arr = PyArray_FromAny(PyTuple_GET_ITEM(args, i), NULL, 0, 0, 0, NULL);
+        if (arr == NULL) goto fail;
+        if ((multi->iters[i] =                                  \
+             (PyArrayIterObject *)PyArray_IterNew(arr))==NULL)
+            goto fail;
+        Py_DECREF(arr);
+    }
+    if (PyArray_Broadcast(multi) < 0) goto fail;
+    PyArray_MultiIter_RESET(multi);
 
-        return (PyObject *)multi;
+    return (PyObject *)multi;
 
  fail:
-        Py_DECREF(multi);
-        return NULL;
+    Py_DECREF(multi);
+    return NULL;
 }
 
 static PyObject *
 arraymultiter_next(PyArrayMultiIterObject *multi)
 {
-        PyObject *ret;
-        int i, n;
+    PyObject *ret;
+    int i, n;
 
-        n = multi->numiter;
-        ret = PyTuple_New(n);
-        if (ret == NULL) return NULL;
-        if (multi->index < multi->size) {
-                for (i=0; i < n; i++) {
-                        PyArrayIterObject *it=multi->iters[i];
-                        PyTuple_SET_ITEM(ret, i,
-                                         PyArray_ToScalar(it->dataptr, it->ao));
-                        PyArray_ITER_NEXT(it);
-                }
-                multi->index++;
-                return ret;
+    n = multi->numiter;
+    ret = PyTuple_New(n);
+    if (ret == NULL) return NULL;
+    if (multi->index < multi->size) {
+        for (i=0; i < n; i++) {
+            PyArrayIterObject *it=multi->iters[i];
+            PyTuple_SET_ITEM(ret, i,
+                             PyArray_ToScalar(it->dataptr, it->ao));
+            PyArray_ITER_NEXT(it);
         }
-        return NULL;
+        multi->index++;
+        return ret;
+    }
+    return NULL;
 }
 
 static void
 arraymultiter_dealloc(PyArrayMultiIterObject *multi)
 {
-        int i;
+    int i;
 
-        for (i=0; i<multi->numiter; i++)
-                Py_XDECREF(multi->iters[i]);
-        multi->ob_type->tp_free((PyObject *)multi);
+    for (i=0; i<multi->numiter; i++)
+        Py_XDECREF(multi->iters[i]);
+    multi->ob_type->tp_free((PyObject *)multi);
 }
 
 static PyObject *
 arraymultiter_size_get(PyArrayMultiIterObject *self)
 {
 #if SIZEOF_INTP <= SIZEOF_LONG
-        return PyInt_FromLong((long) self->size);
+    return PyInt_FromLong((long) self->size);
 #else
-        if (self->size < MAX_LONG)
-                return PyInt_FromLong((long) self->size);
-        else
-                return PyLong_FromLongLong((longlong) self->size);
+    if (self->size < MAX_LONG)
+        return PyInt_FromLong((long) self->size);
+    else
+        return PyLong_FromLongLong((longlong) self->size);
 #endif
 }
 
@@ -10542,135 +10541,135 @@ static PyObject *
 arraymultiter_index_get(PyArrayMultiIterObject *self)
 {
 #if SIZEOF_INTP <= SIZEOF_LONG
-        return PyInt_FromLong((long) self->index);
+    return PyInt_FromLong((long) self->index);
 #else
-        if (self->size < MAX_LONG)
-                return PyInt_FromLong((long) self->index);
-        else
-                return PyLong_FromLongLong((longlong) self->index);
+    if (self->size < MAX_LONG)
+        return PyInt_FromLong((long) self->index);
+    else
+        return PyLong_FromLongLong((longlong) self->index);
 #endif
 }
 
 static PyObject *
 arraymultiter_shape_get(PyArrayMultiIterObject *self)
 {
-        return PyArray_IntTupleFromIntp(self->nd, self->dimensions);
+    return PyArray_IntTupleFromIntp(self->nd, self->dimensions);
 }
 
 static PyObject *
 arraymultiter_iters_get(PyArrayMultiIterObject *self)
 {
-        PyObject *res;
-        int i, n;
-        n = self->numiter;
-        res = PyTuple_New(n);
-        if (res == NULL) return res;
-        for (i=0; i<n; i++) {
-                Py_INCREF(self->iters[i]);
-                PyTuple_SET_ITEM(res, i, (PyObject *)self->iters[i]);
-        }
-        return res;
+    PyObject *res;
+    int i, n;
+    n = self->numiter;
+    res = PyTuple_New(n);
+    if (res == NULL) return res;
+    for (i=0; i<n; i++) {
+        Py_INCREF(self->iters[i]);
+        PyTuple_SET_ITEM(res, i, (PyObject *)self->iters[i]);
+    }
+    return res;
 }
 
 static PyGetSetDef arraymultiter_getsetlist[] = {
-        {"size",
-         (getter)arraymultiter_size_get,
-         NULL, NULL},
-        {"index",
-         (getter)arraymultiter_index_get,
-         NULL, NULL},
-        {"shape",
-         (getter)arraymultiter_shape_get,
-         NULL, NULL},
-        {"iters",
-         (getter)arraymultiter_iters_get,
-         NULL, NULL},
-        {NULL, NULL, NULL, NULL},
+    {"size",
+     (getter)arraymultiter_size_get,
+     NULL, NULL},
+    {"index",
+     (getter)arraymultiter_index_get,
+     NULL, NULL},
+    {"shape",
+     (getter)arraymultiter_shape_get,
+     NULL, NULL},
+    {"iters",
+     (getter)arraymultiter_iters_get,
+     NULL, NULL},
+    {NULL, NULL, NULL, NULL},
 };
 
 static PyMemberDef arraymultiter_members[] = {
-        {"numiter", T_INT, offsetof(PyArrayMultiIterObject, numiter),
-         RO, NULL},
-        {"nd", T_INT, offsetof(PyArrayMultiIterObject, nd), RO, NULL},
-        {NULL},
+    {"numiter", T_INT, offsetof(PyArrayMultiIterObject, numiter),
+     RO, NULL},
+    {"nd", T_INT, offsetof(PyArrayMultiIterObject, nd), RO, NULL},
+    {NULL},
 };
 
 static PyObject *
 arraymultiter_reset(PyArrayMultiIterObject *self, PyObject *args)
 {
-        if (!PyArg_ParseTuple(args, "")) return NULL;
+    if (!PyArg_ParseTuple(args, "")) return NULL;
 
-        PyArray_MultiIter_RESET(self);
-        Py_INCREF(Py_None);
-        return Py_None;
+    PyArray_MultiIter_RESET(self);
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyMethodDef arraymultiter_methods[] = {
-        {"reset", (PyCFunction) arraymultiter_reset, METH_VARARGS, NULL},
-        {NULL, NULL},
+    {"reset", (PyCFunction) arraymultiter_reset, METH_VARARGS, NULL},
+    {NULL, NULL},
 };
 
 static PyTypeObject PyArrayMultiIter_Type = {
-        PyObject_HEAD_INIT(NULL)
-        0,                                       /* ob_size */
-        "numpy.broadcast",                       /* tp_name */
-        sizeof(PyArrayMultiIterObject),          /* tp_basicsize */
-        0,                                       /* tp_itemsize */
-        /* methods */
-        (destructor)arraymultiter_dealloc,      /* tp_dealloc */
-        0,                                      /* tp_print */
-        0,                                      /* tp_getattr */
-        0,                                      /* tp_setattr */
-        0,                                      /* tp_compare */
-        0,                                      /* tp_repr */
-        0,                                      /* tp_as_number */
-        0,                                      /* tp_as_sequence */
-        0,                              /* tp_as_mapping */
-        0,                                      /* tp_hash */
-        0,                                      /* tp_call */
-        0,                                      /* tp_str */
-        0,              /* tp_getattro */
-        0,                                      /* tp_setattro */
-        0,                                      /* tp_as_buffer */
-        Py_TPFLAGS_DEFAULT,                     /* tp_flags */
-        0,                                      /* tp_doc */
-        0,                              /* tp_traverse */
-        0,                                      /* tp_clear */
-        0,                                      /* tp_richcompare */
-        0,                                      /* tp_weaklistoffset */
-        0,                              /* tp_iter */
-        (iternextfunc)arraymultiter_next,       /* tp_iternext */
-        arraymultiter_methods,          /* tp_methods */
-        arraymultiter_members,                  /* tp_members */
-        arraymultiter_getsetlist,               /* tp_getset */
-        0,                                        /* tp_base */
-        0,                                        /* tp_dict */
-        0,                                        /* tp_descr_get */
-        0,                                        /* tp_descr_set */
-        0,                                        /* tp_dictoffset */
-        (initproc)0,                              /* tp_init */
-        0,                                        /* tp_alloc */
-        arraymultiter_new,                        /* tp_new */
-        0,                                        /* tp_free */
-        0,                                        /* tp_is_gc */
-        0,                                        /* tp_bases */
-        0,                                        /* tp_mro */
-        0,                                        /* tp_cache */
-        0,                                        /* tp_subclasses */
-        0                                         /* tp_weaklist */
+    PyObject_HEAD_INIT(NULL)
+    0,                                       /* ob_size */
+    "numpy.broadcast",                       /* tp_name */
+    sizeof(PyArrayMultiIterObject),          /* tp_basicsize */
+    0,                                       /* tp_itemsize */
+    /* methods */
+    (destructor)arraymultiter_dealloc,      /* tp_dealloc */
+    0,                                      /* tp_print */
+    0,                                      /* tp_getattr */
+    0,                                      /* tp_setattr */
+    0,                                      /* tp_compare */
+    0,                                      /* tp_repr */
+    0,                                      /* tp_as_number */
+    0,                                      /* tp_as_sequence */
+    0,                              /* tp_as_mapping */
+    0,                                      /* tp_hash */
+    0,                                      /* tp_call */
+    0,                                      /* tp_str */
+    0,              /* tp_getattro */
+    0,                                      /* tp_setattro */
+    0,                                      /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                     /* tp_flags */
+    0,                                      /* tp_doc */
+    0,                              /* tp_traverse */
+    0,                                      /* tp_clear */
+    0,                                      /* tp_richcompare */
+    0,                                      /* tp_weaklistoffset */
+    0,                              /* tp_iter */
+    (iternextfunc)arraymultiter_next,       /* tp_iternext */
+    arraymultiter_methods,          /* tp_methods */
+    arraymultiter_members,                  /* tp_members */
+    arraymultiter_getsetlist,               /* tp_getset */
+    0,                                        /* tp_base */
+    0,                                        /* tp_dict */
+    0,                                        /* tp_descr_get */
+    0,                                        /* tp_descr_set */
+    0,                                        /* tp_dictoffset */
+    (initproc)0,                              /* tp_init */
+    0,                                        /* tp_alloc */
+    arraymultiter_new,                        /* tp_new */
+    0,                                        /* tp_free */
+    0,                                        /* tp_is_gc */
+    0,                                        /* tp_bases */
+    0,                                        /* tp_mro */
+    0,                                        /* tp_cache */
+    0,                                        /* tp_subclasses */
+    0                                         /* tp_weaklist */
 };
 
 /*OBJECT_API*/
 static PyArray_Descr *
 PyArray_DescrNewFromType(int type_num)
 {
-        PyArray_Descr *old;
-        PyArray_Descr *new;
+    PyArray_Descr *old;
+    PyArray_Descr *new;
 
-        old = PyArray_DescrFromType(type_num);
-        new = PyArray_DescrNew(old);
-        Py_DECREF(old);
-        return new;
+    old = PyArray_DescrFromType(type_num);
+    new = PyArray_DescrNew(old);
+    Py_DECREF(old);
+    return new;
 }
 
 /*** Array Descr Objects for dynamic types **/
@@ -10691,27 +10690,27 @@ PyArray_DescrNewFromType(int type_num)
 static PyArray_Descr *
 PyArray_DescrNew(PyArray_Descr *base)
 {
-        PyArray_Descr *new;
-
-        new = PyObject_New(PyArray_Descr, &PyArrayDescr_Type);
-        if (new == NULL) return NULL;
-        /* Don't copy PyObject_HEAD part */
-        memcpy((char *)new+sizeof(PyObject),
-               (char *)base+sizeof(PyObject),
-               sizeof(PyArray_Descr)-sizeof(PyObject));
-
-        if (new->fields == Py_None) new->fields = NULL;
-        Py_XINCREF(new->fields);
-        Py_XINCREF(new->names);
-        if (new->subarray) {
-                new->subarray = _pya_malloc(sizeof(PyArray_ArrayDescr));
-                memcpy(new->subarray, base->subarray,
-                       sizeof(PyArray_ArrayDescr));
-                Py_INCREF(new->subarray->shape);
-                Py_INCREF(new->subarray->base);
-        }
-        Py_XINCREF(new->typeobj);
-        return new;
+    PyArray_Descr *new;
+
+    new = PyObject_New(PyArray_Descr, &PyArrayDescr_Type);
+    if (new == NULL) return NULL;
+    /* Don't copy PyObject_HEAD part */
+    memcpy((char *)new+sizeof(PyObject),
+           (char *)base+sizeof(PyObject),
+           sizeof(PyArray_Descr)-sizeof(PyObject));
+
+    if (new->fields == Py_None) new->fields = NULL;
+    Py_XINCREF(new->fields);
+    Py_XINCREF(new->names);
+    if (new->subarray) {
+        new->subarray = _pya_malloc(sizeof(PyArray_ArrayDescr));
+        memcpy(new->subarray, base->subarray,
+               sizeof(PyArray_ArrayDescr));
+        Py_INCREF(new->subarray->shape);
+        Py_INCREF(new->subarray->base);
+    }
+    Py_XINCREF(new->typeobj);
+    return new;
 }
 
 /* should never be called for builtin-types unless
@@ -10720,23 +10719,23 @@ PyArray_DescrNew(PyArray_Descr *base)
 static void
 arraydescr_dealloc(PyArray_Descr *self)
 {
-        if (self->fields == Py_None) {
-                fprintf(stderr, "*** Reference count error detected: \n" \
-                        "an attempt was made to deallocate %d (%c) ***\n", 
-                        self->type_num, self->type);
-                Py_INCREF(self);
-                Py_INCREF(self);
-                return;
-        }
-        Py_XDECREF(self->typeobj);
-        Py_XDECREF(self->names);
-        Py_XDECREF(self->fields);
-        if (self->subarray) {
-                Py_DECREF(self->subarray->shape);
-                Py_DECREF(self->subarray->base);
-                _pya_free(self->subarray);
-        }
-        self->ob_type->tp_free((PyObject *)self);
+    if (self->fields == Py_None) {
+        fprintf(stderr, "*** Reference count error detected: \n" \
+                "an attempt was made to deallocate %d (%c) ***\n",
+                self->type_num, self->type);
+        Py_INCREF(self);
+        Py_INCREF(self);
+        return;
+    }
+    Py_XDECREF(self->typeobj);
+    Py_XDECREF(self->names);
+    Py_XDECREF(self->fields);
+    if (self->subarray) {
+        Py_DECREF(self->subarray->shape);
+        Py_DECREF(self->subarray->base);
+        _pya_free(self->subarray);
+    }
+    self->ob_type->tp_free((PyObject *)self);
 }
 
 /* we need to be careful about setting attributes because these
@@ -10744,133 +10743,133 @@ arraydescr_dealloc(PyArray_Descr *self)
    data.  Currently no attributes of dtype objects can be set.
 */
 static PyMemberDef arraydescr_members[] = {
-        {"type", T_OBJECT, offsetof(PyArray_Descr, typeobj), RO, NULL},
-        {"kind", T_CHAR, offsetof(PyArray_Descr, kind), RO, NULL},
-        {"char", T_CHAR, offsetof(PyArray_Descr, type), RO, NULL},
-        {"num", T_INT, offsetof(PyArray_Descr, type_num), RO, NULL},
-        {"byteorder", T_CHAR, offsetof(PyArray_Descr, byteorder), RO, NULL},
-        {"itemsize", T_INT, offsetof(PyArray_Descr, elsize), RO, NULL},
-        {"alignment", T_INT, offsetof(PyArray_Descr, alignment), RO, NULL},
-        {"flags", T_UBYTE, offsetof(PyArray_Descr, hasobject), RO, NULL},
-        {"names", T_OBJECT, offsetof(PyArray_Descr, names), RO, NULL},
-        {NULL},
+    {"type", T_OBJECT, offsetof(PyArray_Descr, typeobj), RO, NULL},
+    {"kind", T_CHAR, offsetof(PyArray_Descr, kind), RO, NULL},
+    {"char", T_CHAR, offsetof(PyArray_Descr, type), RO, NULL},
+    {"num", T_INT, offsetof(PyArray_Descr, type_num), RO, NULL},
+    {"byteorder", T_CHAR, offsetof(PyArray_Descr, byteorder), RO, NULL},
+    {"itemsize", T_INT, offsetof(PyArray_Descr, elsize), RO, NULL},
+    {"alignment", T_INT, offsetof(PyArray_Descr, alignment), RO, NULL},
+    {"flags", T_UBYTE, offsetof(PyArray_Descr, hasobject), RO, NULL},
+    {"names", T_OBJECT, offsetof(PyArray_Descr, names), RO, NULL},
+    {NULL},
 };
 
 static PyObject *
 arraydescr_subdescr_get(PyArray_Descr *self)
 {
-        if (self->subarray == NULL) {
-                Py_INCREF(Py_None);
-                return Py_None;
-        }
-        return Py_BuildValue("OO", (PyObject *)self->subarray->base,
-                             self->subarray->shape);
+    if (self->subarray == NULL) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    return Py_BuildValue("OO", (PyObject *)self->subarray->base,
+                         self->subarray->shape);
 }
 
 static PyObject *
 arraydescr_protocol_typestr_get(PyArray_Descr *self)
 {
-        char basic_=self->kind;
-        char endian = self->byteorder;
-        int size=self->elsize;
+    char basic_=self->kind;
+    char endian = self->byteorder;
+    int size=self->elsize;
 
-        if (endian == '=') {
-                endian = '<';
-                if (!PyArray_IsNativeByteOrder(endian)) endian = '>';
-        }
+    if (endian == '=') {
+        endian = '<';
+        if (!PyArray_IsNativeByteOrder(endian)) endian = '>';
+    }
 
-        if (self->type_num == PyArray_UNICODE) {
-                size >>= 2;
-        }
-        return PyString_FromFormat("%c%c%d", endian, basic_, size);
+    if (self->type_num == PyArray_UNICODE) {
+        size >>= 2;
+    }
+    return PyString_FromFormat("%c%c%d", endian, basic_, size);
 }
 
 static PyObject *
 arraydescr_typename_get(PyArray_Descr *self)
 {
-        int len;
-        PyTypeObject *typeobj = self->typeobj;
-        PyObject *res;
-	char *s;
-        static int prefix_len=0;
-        
-        if (PyTypeNum_ISUSERDEF(self->type_num)) {
-		s = strrchr(typeobj->tp_name, '.');
-		if (s == NULL) {
-			res = PyString_FromString(typeobj->tp_name);
-		}
-		else {
-			res = PyString_FromStringAndSize(s+1, strlen(s)-1);
-		}
-		return res;
-        }
-        else {
-                if (prefix_len == 0)
-                        prefix_len = strlen("numpy.");
+    int len;
+    PyTypeObject *typeobj = self->typeobj;
+    PyObject *res;
+    char *s;
+    static int prefix_len=0;
 
-                len = strlen(typeobj->tp_name);
-		if (*(typeobj->tp_name + (len-1)) == '_')
-			len-=1;
-		len -= prefix_len;
-		res = PyString_FromStringAndSize(typeobj->tp_name+prefix_len, len);
+    if (PyTypeNum_ISUSERDEF(self->type_num)) {
+        s = strrchr(typeobj->tp_name, '.');
+        if (s == NULL) {
+            res = PyString_FromString(typeobj->tp_name);
         }
-        if (PyTypeNum_ISFLEXIBLE(self->type_num) && self->elsize != 0) {
-                PyObject *p;
-                p = PyString_FromFormat("%d", self->elsize * 8);
-                PyString_ConcatAndDel(&res, p);
+        else {
+            res = PyString_FromStringAndSize(s+1, strlen(s)-1);
         }
         return res;
+    }
+    else {
+        if (prefix_len == 0)
+            prefix_len = strlen("numpy.");
+
+        len = strlen(typeobj->tp_name);
+        if (*(typeobj->tp_name + (len-1)) == '_')
+            len-=1;
+        len -= prefix_len;
+        res = PyString_FromStringAndSize(typeobj->tp_name+prefix_len, len);
+    }
+    if (PyTypeNum_ISFLEXIBLE(self->type_num) && self->elsize != 0) {
+        PyObject *p;
+        p = PyString_FromFormat("%d", self->elsize * 8);
+        PyString_ConcatAndDel(&res, p);
+    }
+    return res;
 }
 
 static PyObject *
 arraydescr_base_get(PyArray_Descr *self)
 {
-        if (self->subarray == NULL) {
-                Py_INCREF(self);
-                return (PyObject *)self;
-        }
-        Py_INCREF(self->subarray->base);
-        return (PyObject *)(self->subarray->base);
+    if (self->subarray == NULL) {
+        Py_INCREF(self);
+        return (PyObject *)self;
+    }
+    Py_INCREF(self->subarray->base);
+    return (PyObject *)(self->subarray->base);
 }
 
 static PyObject *
 arraydescr_shape_get(PyArray_Descr *self)
 {
-        if (self->subarray == NULL) {
-                return PyTuple_New(0);
-        }
-        if (PyTuple_Check(self->subarray->shape)) {
-                Py_INCREF(self->subarray->shape);
-                return (PyObject *)(self->subarray->shape);
-        }
-        return Py_BuildValue("(O)", self->subarray->shape);
+    if (self->subarray == NULL) {
+        return PyTuple_New(0);
+    }
+    if (PyTuple_Check(self->subarray->shape)) {
+        Py_INCREF(self->subarray->shape);
+        return (PyObject *)(self->subarray->shape);
+    }
+    return Py_BuildValue("(O)", self->subarray->shape);
 }
 
 static PyObject *
 arraydescr_protocol_descr_get(PyArray_Descr *self)
 {
-        PyObject *dobj, *res;
-        PyObject *_numpy_internal;
-
-        if (self->names == NULL) {
-                /* get default */
-                dobj = PyTuple_New(2);
-                if (dobj == NULL) return NULL;
-                PyTuple_SET_ITEM(dobj, 0, PyString_FromString(""));
-                PyTuple_SET_ITEM(dobj, 1, \
-                                 arraydescr_protocol_typestr_get(self));
-                res = PyList_New(1);
-                if (res == NULL) {Py_DECREF(dobj); return NULL;}
-                PyList_SET_ITEM(res, 0, dobj);
-                return res;
-        }
-
-        _numpy_internal = PyImport_ImportModule("numpy.core._internal");
-        if (_numpy_internal == NULL) return NULL;
-        res = PyObject_CallMethod(_numpy_internal, "_array_descr",
-                                  "O", self);
-        Py_DECREF(_numpy_internal);
+    PyObject *dobj, *res;
+    PyObject *_numpy_internal;
+
+    if (self->names == NULL) {
+        /* get default */
+        dobj = PyTuple_New(2);
+        if (dobj == NULL) return NULL;
+        PyTuple_SET_ITEM(dobj, 0, PyString_FromString(""));
+        PyTuple_SET_ITEM(dobj, 1, \
+                         arraydescr_protocol_typestr_get(self));
+        res = PyList_New(1);
+        if (res == NULL) {Py_DECREF(dobj); return NULL;}
+        PyList_SET_ITEM(res, 0, dobj);
         return res;
+    }
+
+    _numpy_internal = PyImport_ImportModule("numpy.core._internal");
+    if (_numpy_internal == NULL) return NULL;
+    res = PyObject_CallMethod(_numpy_internal, "_array_descr",
+                              "O", self);
+    Py_DECREF(_numpy_internal);
+    return res;
 }
 
 /* returns 1 for a builtin type
@@ -10880,31 +10879,31 @@ arraydescr_protocol_descr_get(PyArray_Descr *self)
 static PyObject *
 arraydescr_isbuiltin_get(PyArray_Descr *self)
 {
-        long val;
-        val = 0;
-        if (self->fields == Py_None) val = 1;
-        if (PyTypeNum_ISUSERDEF(self->type_num)) val = 2;
-        return PyInt_FromLong(val);
+    long val;
+    val = 0;
+    if (self->fields == Py_None) val = 1;
+    if (PyTypeNum_ISUSERDEF(self->type_num)) val = 2;
+    return PyInt_FromLong(val);
 }
 
 static int
 _arraydescr_isnative(PyArray_Descr *self)
 {
-        if (self->names == NULL) {
-                return PyArray_ISNBO(self->byteorder);
-        }
-        else {
-                PyObject *key, *value, *title=NULL;
-                PyArray_Descr *new;
-                int offset;
-                Py_ssize_t pos=0;
-                while(PyDict_Next(self->fields, &pos, &key, &value)) {
-                        if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
-                                              &title)) return -1;
-                        if (!_arraydescr_isnative(new)) return 0;
-                }
+    if (self->names == NULL) {
+        return PyArray_ISNBO(self->byteorder);
+    }
+    else {
+        PyObject *key, *value, *title=NULL;
+        PyArray_Descr *new;
+        int offset;
+        Py_ssize_t pos=0;
+        while(PyDict_Next(self->fields, &pos, &key, &value)) {
+            if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
+                                  &title)) return -1;
+            if (!_arraydescr_isnative(new)) return 0;
         }
-        return 1;
+    }
+    return 1;
 }
 
 /* return Py_True if this data-type descriptor
@@ -10916,99 +10915,99 @@ _arraydescr_isnative(PyArray_Descr *self)
 static PyObject *
 arraydescr_isnative_get(PyArray_Descr *self)
 {
-        PyObject *ret;
-        int retval;
-        retval = _arraydescr_isnative(self);
-        if (retval == -1) return NULL;
-        ret = (retval ? Py_True : Py_False);
-        Py_INCREF(ret);
-        return ret;
+    PyObject *ret;
+    int retval;
+    retval = _arraydescr_isnative(self);
+    if (retval == -1) return NULL;
+    ret = (retval ? Py_True : Py_False);
+    Py_INCREF(ret);
+    return ret;
 }
 
 static PyObject *
 arraydescr_fields_get(PyArray_Descr *self)
 {
-        if (self->names == NULL) {
-                Py_INCREF(Py_None);
-                return Py_None;
-        }
-        return PyDictProxy_New(self->fields);
+    if (self->names == NULL) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    return PyDictProxy_New(self->fields);
 }
 
 static PyObject *
 arraydescr_hasobject_get(PyArray_Descr *self)
 {
-        PyObject *res;
-        if (PyDataType_FLAGCHK(self, NPY_ITEM_HASOBJECT))
-                res = Py_True;
-        else
-                res = Py_False;
-        Py_INCREF(res);
-        return res;
+    PyObject *res;
+    if (PyDataType_FLAGCHK(self, NPY_ITEM_HASOBJECT))
+        res = Py_True;
+    else
+        res = Py_False;
+    Py_INCREF(res);
+    return res;
 }
 
 static PyGetSetDef arraydescr_getsets[] = {
-        {"subdtype",
-         (getter)arraydescr_subdescr_get,
-         NULL, NULL},
-        {"descr",
-         (getter)arraydescr_protocol_descr_get,
-         NULL, NULL},
-        {"str",
-         (getter)arraydescr_protocol_typestr_get,
-         NULL, NULL},
-        {"name",
-         (getter)arraydescr_typename_get,
-         NULL, NULL},
-        {"base",
-         (getter)arraydescr_base_get,
-         NULL, NULL},
-        {"shape",
-         (getter)arraydescr_shape_get,
-         NULL, NULL},
-        {"isbuiltin",
-         (getter)arraydescr_isbuiltin_get,
-         NULL, NULL},
-        {"isnative",
-         (getter)arraydescr_isnative_get,
-         NULL, NULL},
-        {"fields",
-         (getter)arraydescr_fields_get,
-         NULL, NULL},
-        {"hasobject",
-         (getter)arraydescr_hasobject_get,
-         NULL, NULL},
-        {NULL, NULL, NULL, NULL},
+    {"subdtype",
+     (getter)arraydescr_subdescr_get,
+     NULL, NULL},
+    {"descr",
+     (getter)arraydescr_protocol_descr_get,
+     NULL, NULL},
+    {"str",
+     (getter)arraydescr_protocol_typestr_get,
+     NULL, NULL},
+    {"name",
+     (getter)arraydescr_typename_get,
+     NULL, NULL},
+    {"base",
+     (getter)arraydescr_base_get,
+     NULL, NULL},
+    {"shape",
+     (getter)arraydescr_shape_get,
+     NULL, NULL},
+    {"isbuiltin",
+     (getter)arraydescr_isbuiltin_get,
+     NULL, NULL},
+    {"isnative",
+     (getter)arraydescr_isnative_get,
+     NULL, NULL},
+    {"fields",
+     (getter)arraydescr_fields_get,
+     NULL, NULL},
+    {"hasobject",
+     (getter)arraydescr_hasobject_get,
+     NULL, NULL},
+    {NULL, NULL, NULL, NULL},
 };
 
 static PyObject *
 arraydescr_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
 {
-        PyObject *odescr;
-        PyArray_Descr *descr, *conv;
-        Bool align=FALSE;
-        Bool copy=FALSE;
-        static char *kwlist[] = {"dtype", "align", "copy", NULL};
+    PyObject *odescr;
+    PyArray_Descr *descr, *conv;
+    Bool align=FALSE;
+    Bool copy=FALSE;
+    static char *kwlist[] = {"dtype", "align", "copy", NULL};
 
-        if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&O&",
-                                         kwlist, &odescr, 
-                                         PyArray_BoolConverter, &align,
-                                         PyArray_BoolConverter, &copy))
-                return NULL;
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&O&",
+                                     kwlist, &odescr,
+                                     PyArray_BoolConverter, &align,
+                                     PyArray_BoolConverter, &copy))
+        return NULL;
 
-        if (align) {
-                if (!PyArray_DescrAlignConverter(odescr, &conv))
-                        return NULL;
-        }
-        else if (!PyArray_DescrConverter(odescr, &conv))
-                return NULL;
-        /* Get a new copy of it unless it's already a copy */
-        if (copy && conv->fields == Py_None) {
-                descr = PyArray_DescrNew(conv);
-                Py_DECREF(conv);
-                conv = descr;
-        }
-        return (PyObject *)conv;
+    if (align) {
+        if (!PyArray_DescrAlignConverter(odescr, &conv))
+            return NULL;
+    }
+    else if (!PyArray_DescrConverter(odescr, &conv))
+        return NULL;
+    /* Get a new copy of it unless it's already a copy */
+    if (copy && conv->fields == Py_None) {
+        descr = PyArray_DescrNew(conv);
+        Py_DECREF(conv);
+        conv = descr;
+    }
+    return (PyObject *)conv;
 }
 
 
@@ -11016,104 +11015,104 @@ arraydescr_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
 static PyObject *
 arraydescr_reduce(PyArray_Descr *self, PyObject *args)
 {
-        /* version number of this pickle type. Increment if we need to
-           change the format. Be sure to handle the old versions in
-           arraydescr_setstate. */
-        const int version = 3;
-        PyObject *ret, *mod, *obj;
-        PyObject *state;
-        char endian;
-        int elsize, alignment;
-
-        ret = PyTuple_New(3);
-        if (ret == NULL) return NULL;
-        mod = PyImport_ImportModule("numpy.core.multiarray");
-        if (mod == NULL) {Py_DECREF(ret); return NULL;}
-        obj = PyObject_GetAttrString(mod, "dtype");
-        Py_DECREF(mod);
-        if (obj == NULL) {Py_DECREF(ret); return NULL;}
-        PyTuple_SET_ITEM(ret, 0, obj);
-        if (PyTypeNum_ISUSERDEF(self->type_num) ||              \
-            ((self->type_num == PyArray_VOID &&                 \
-              self->typeobj != &PyVoidArrType_Type))) {
-                obj = (PyObject *)self->typeobj;
-                Py_INCREF(obj);
-        }
-        else {
-                elsize = self->elsize;
-                if (self->type_num == PyArray_UNICODE) {
-                        elsize >>= 2;
-                }
-                obj = PyString_FromFormat("%c%d",self->kind, elsize);
-        }
-        PyTuple_SET_ITEM(ret, 1, Py_BuildValue("(Nii)", obj, 0, 1));
-
-        /* Now return the state which is at least
-           byteorder, subarray, and fields */
-        endian = self->byteorder;
-        if (endian == '=') {
-                endian = '<';
-                if (!PyArray_IsNativeByteOrder(endian)) endian = '>';
-        }
-        state = PyTuple_New(8);
-        PyTuple_SET_ITEM(state, 0, PyInt_FromLong(version));
-        PyTuple_SET_ITEM(state, 1, PyString_FromFormat("%c", endian));
-        PyTuple_SET_ITEM(state, 2, arraydescr_subdescr_get(self));
-        if (self->names) {
-                Py_INCREF(self->names);
-                Py_INCREF(self->fields);
-                PyTuple_SET_ITEM(state, 3, self->names);
-                PyTuple_SET_ITEM(state, 4, self->fields);
-        }
-        else {
-                PyTuple_SET_ITEM(state, 3, Py_None);
-                PyTuple_SET_ITEM(state, 4, Py_None);
-                Py_INCREF(Py_None);
-                Py_INCREF(Py_None);
+    /* version number of this pickle type. Increment if we need to
+       change the format. Be sure to handle the old versions in
+       arraydescr_setstate. */
+    const int version = 3;
+    PyObject *ret, *mod, *obj;
+    PyObject *state;
+    char endian;
+    int elsize, alignment;
+
+    ret = PyTuple_New(3);
+    if (ret == NULL) return NULL;
+    mod = PyImport_ImportModule("numpy.core.multiarray");
+    if (mod == NULL) {Py_DECREF(ret); return NULL;}
+    obj = PyObject_GetAttrString(mod, "dtype");
+    Py_DECREF(mod);
+    if (obj == NULL) {Py_DECREF(ret); return NULL;}
+    PyTuple_SET_ITEM(ret, 0, obj);
+    if (PyTypeNum_ISUSERDEF(self->type_num) ||              \
+        ((self->type_num == PyArray_VOID &&                 \
+          self->typeobj != &PyVoidArrType_Type))) {
+        obj = (PyObject *)self->typeobj;
+        Py_INCREF(obj);
+    }
+    else {
+        elsize = self->elsize;
+        if (self->type_num == PyArray_UNICODE) {
+            elsize >>= 2;
         }
+        obj = PyString_FromFormat("%c%d",self->kind, elsize);
+    }
+    PyTuple_SET_ITEM(ret, 1, Py_BuildValue("(Nii)", obj, 0, 1));
+
+    /* Now return the state which is at least
+       byteorder, subarray, and fields */
+    endian = self->byteorder;
+    if (endian == '=') {
+        endian = '<';
+        if (!PyArray_IsNativeByteOrder(endian)) endian = '>';
+    }
+    state = PyTuple_New(8);
+    PyTuple_SET_ITEM(state, 0, PyInt_FromLong(version));
+    PyTuple_SET_ITEM(state, 1, PyString_FromFormat("%c", endian));
+    PyTuple_SET_ITEM(state, 2, arraydescr_subdescr_get(self));
+    if (self->names) {
+        Py_INCREF(self->names);
+        Py_INCREF(self->fields);
+        PyTuple_SET_ITEM(state, 3, self->names);
+        PyTuple_SET_ITEM(state, 4, self->fields);
+    }
+    else {
+        PyTuple_SET_ITEM(state, 3, Py_None);
+        PyTuple_SET_ITEM(state, 4, Py_None);
+        Py_INCREF(Py_None);
+        Py_INCREF(Py_None);
+    }
 
-        /* for extended types it also includes elsize and alignment */
-        if (PyTypeNum_ISEXTENDED(self->type_num)) {
-                elsize = self->elsize;
-                alignment = self->alignment;
-        }
-        else {elsize = -1; alignment = -1;}
+    /* for extended types it also includes elsize and alignment */
+    if (PyTypeNum_ISEXTENDED(self->type_num)) {
+        elsize = self->elsize;
+        alignment = self->alignment;
+    }
+    else {elsize = -1; alignment = -1;}
 
-        PyTuple_SET_ITEM(state, 5, PyInt_FromLong(elsize));
-        PyTuple_SET_ITEM(state, 6, PyInt_FromLong(alignment));
-        PyTuple_SET_ITEM(state, 7, PyInt_FromLong(self->hasobject));
+    PyTuple_SET_ITEM(state, 5, PyInt_FromLong(elsize));
+    PyTuple_SET_ITEM(state, 6, PyInt_FromLong(alignment));
+    PyTuple_SET_ITEM(state, 7, PyInt_FromLong(self->hasobject));
 
-        PyTuple_SET_ITEM(ret, 2, state);
-        return ret;
+    PyTuple_SET_ITEM(ret, 2, state);
+    return ret;
 }
 
 /* returns 1 if this data-type has an object portion
    used when setting the state because hasobject is not stored.
- */
+*/
 static int
 _descr_find_object(PyArray_Descr *self)
 {
-        if (self->hasobject || self->type_num == PyArray_OBJECT || 
-            self->kind == 'O')
+    if (self->hasobject || self->type_num == PyArray_OBJECT ||
+        self->kind == 'O')
+        return NPY_OBJECT_DTYPE_FLAGS;
+    if (PyDescr_HASFIELDS(self)) {
+        PyObject *key, *value, *title=NULL;
+        PyArray_Descr *new;
+        int offset;
+        Py_ssize_t pos=0;
+        while (PyDict_Next(self->fields, &pos, &key, &value)) {
+            if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
+                                  &title)) {
+                PyErr_Clear();
+                return 0;
+            }
+            if (_descr_find_object(new)) {
+                new->hasobject = NPY_OBJECT_DTYPE_FLAGS;
                 return NPY_OBJECT_DTYPE_FLAGS;
-        if (PyDescr_HASFIELDS(self)) {
-                PyObject *key, *value, *title=NULL;
-                PyArray_Descr *new;
-                int offset;
-                Py_ssize_t pos=0;
-                while (PyDict_Next(self->fields, &pos, &key, &value)) {
-                        if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset,
-                                              &title)) {
-                                PyErr_Clear();
-                                return 0;
-                        }
-                        if (_descr_find_object(new)) {
-                                new->hasobject = NPY_OBJECT_DTYPE_FLAGS;
-                                return NPY_OBJECT_DTYPE_FLAGS;
-                        }
-                }
+            }
         }
-        return 0;
+    }
+    return 0;
 }
 
 /* state is at least byteorder, subarray, and fields but could include elsize
@@ -11123,373 +11122,373 @@ _descr_find_object(PyArray_Descr *self)
 static PyObject *
 arraydescr_setstate(PyArray_Descr *self, PyObject *args)
 {
-        int elsize = -1, alignment = -1;
-        int version = 3;
-        char endian;
-        PyObject *subarray, *fields, *names=NULL;
-        int incref_names = 1;
-        int dtypeflags=0;
+    int elsize = -1, alignment = -1;
+    int version = 3;
+    char endian;
+    PyObject *subarray, *fields, *names=NULL;
+    int incref_names = 1;
+    int dtypeflags=0;
 
-        if (self->fields == Py_None) {Py_INCREF(Py_None); return Py_None;}
+    if (self->fields == Py_None) {Py_INCREF(Py_None); return Py_None;}
 
-        if (PyTuple_GET_SIZE(args) != 1 || 
-            !(PyTuple_Check(PyTuple_GET_ITEM(args, 0)))) {
-                PyErr_BadInternalCall();
-                return NULL;
+    if (PyTuple_GET_SIZE(args) != 1 ||
+        !(PyTuple_Check(PyTuple_GET_ITEM(args, 0)))) {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+    switch (PyTuple_GET_SIZE(PyTuple_GET_ITEM(args,0))) {
+    case 8:
+        if (!PyArg_ParseTuple(args, "(icOOOiii)", &version, &endian,
+                              &subarray, &names, &fields, &elsize,
+                              &alignment, &dtypeflags)) {
+            return NULL;
         }
-        switch (PyTuple_GET_SIZE(PyTuple_GET_ITEM(args,0))) {
-        case 8:
-                if (!PyArg_ParseTuple(args, "(icOOOiii)", &version, &endian, 
-                                      &subarray, &names, &fields, &elsize, 
-                                      &alignment, &dtypeflags)) {
-                        return NULL;
-                }
-                break;
-        case 7:
-                if (!PyArg_ParseTuple(args, "(icOOOii)", &version, &endian, 
-                                      &subarray, &names, &fields, &elsize, 
-                                      &alignment)) {
-                        return NULL;
-                }
-                break;
-        case 6:
-                if (!PyArg_ParseTuple(args, "(icOOii)", &version, 
-                                      &endian, &subarray, &fields, 
-                                      &elsize, &alignment)) {
-                        PyErr_Clear();
-                }
-                break;
-        case 5:
-                version = 0;
-                if (!PyArg_ParseTuple(args, "(cOOii)", 
-                                      &endian, &subarray, &fields, &elsize, 
-                                      &alignment)) {
-                        return NULL;
-                }
-                break;
-        default:
-                version = -1; /* raise an error */
+        break;
+    case 7:
+        if (!PyArg_ParseTuple(args, "(icOOOii)", &version, &endian,
+                              &subarray, &names, &fields, &elsize,
+                              &alignment)) {
+            return NULL;
         }
-        
-        /* If we ever need another pickle format, increment the version
-           number. But we should still be able to handle the old versions.
-        */
-        if (version < 0 || version > 3) {
-            PyErr_Format(PyExc_ValueError,
-                         "can't handle version %d of numpy.dtype pickle",
-                         version);
+        break;
+    case 6:
+        if (!PyArg_ParseTuple(args, "(icOOii)", &version,
+                              &endian, &subarray, &fields,
+                              &elsize, &alignment)) {
+            PyErr_Clear();
+        }
+        break;
+    case 5:
+        version = 0;
+        if (!PyArg_ParseTuple(args, "(cOOii)",
+                              &endian, &subarray, &fields, &elsize,
+                              &alignment)) {
             return NULL;
         }
+        break;
+    default:
+        version = -1; /* raise an error */
+    }
 
-        if (version == 1 || version == 0) {
-            if (fields != Py_None) {
-                PyObject *key, *list;
-                key = PyInt_FromLong(-1);
-                list = PyDict_GetItem(fields, key);
-                if (!list) return NULL;
-                    Py_INCREF(list);
-                    names = list;
-                    PyDict_DelItem(fields, key);
-                    incref_names = 0;
-            }
-            else {
-                names = Py_None;
-            }
+    /* If we ever need another pickle format, increment the version
+       number. But we should still be able to handle the old versions.
+    */
+    if (version < 0 || version > 3) {
+        PyErr_Format(PyExc_ValueError,
+                     "can't handle version %d of numpy.dtype pickle",
+                     version);
+        return NULL;
+    }
+
+    if (version == 1 || version == 0) {
+        if (fields != Py_None) {
+            PyObject *key, *list;
+            key = PyInt_FromLong(-1);
+            list = PyDict_GetItem(fields, key);
+            if (!list) return NULL;
+            Py_INCREF(list);
+            names = list;
+            PyDict_DelItem(fields, key);
+            incref_names = 0;
+        }
+        else {
+            names = Py_None;
         }
+    }
 
 
-        if ((fields == Py_None && names != Py_None) ||  \
-            (names == Py_None && fields != Py_None)) {
-            PyErr_Format(PyExc_ValueError,
-                         "inconsistent fields and names");
-            return NULL;
-        }
+    if ((fields == Py_None && names != Py_None) ||  \
+        (names == Py_None && fields != Py_None)) {
+        PyErr_Format(PyExc_ValueError,
+                     "inconsistent fields and names");
+        return NULL;
+    }
 
-        if (endian != '|' &&
-            PyArray_IsNativeByteOrder(endian)) endian = '=';
+    if (endian != '|' &&
+        PyArray_IsNativeByteOrder(endian)) endian = '=';
 
-        self->byteorder = endian;
-        if (self->subarray) {
-                Py_XDECREF(self->subarray->base);
-                Py_XDECREF(self->subarray->shape);
-                _pya_free(self->subarray);
-        }
-        self->subarray = NULL;
+    self->byteorder = endian;
+    if (self->subarray) {
+        Py_XDECREF(self->subarray->base);
+        Py_XDECREF(self->subarray->shape);
+        _pya_free(self->subarray);
+    }
+    self->subarray = NULL;
 
-        if (subarray != Py_None) {
-                self->subarray = _pya_malloc(sizeof(PyArray_ArrayDescr));
-                self->subarray->base = (PyArray_Descr *)PyTuple_GET_ITEM(subarray, 0);
-                Py_INCREF(self->subarray->base);
-                self->subarray->shape = PyTuple_GET_ITEM(subarray, 1);
-                Py_INCREF(self->subarray->shape);
-        }
+    if (subarray != Py_None) {
+        self->subarray = _pya_malloc(sizeof(PyArray_ArrayDescr));
+        self->subarray->base = (PyArray_Descr *)PyTuple_GET_ITEM(subarray, 0);
+        Py_INCREF(self->subarray->base);
+        self->subarray->shape = PyTuple_GET_ITEM(subarray, 1);
+        Py_INCREF(self->subarray->shape);
+    }
 
-        if (fields != Py_None) {
-                Py_XDECREF(self->fields);
-                self->fields = fields;
-                Py_INCREF(fields);
-                Py_XDECREF(self->names);
-                self->names = names;
-                if (incref_names)
-                    Py_INCREF(names);
-        }
+    if (fields != Py_None) {
+        Py_XDECREF(self->fields);
+        self->fields = fields;
+        Py_INCREF(fields);
+        Py_XDECREF(self->names);
+        self->names = names;
+        if (incref_names)
+            Py_INCREF(names);
+    }
 
-        if (PyTypeNum_ISEXTENDED(self->type_num)) {
-                self->elsize = elsize;
-                self->alignment = alignment;
-        }
+    if (PyTypeNum_ISEXTENDED(self->type_num)) {
+        self->elsize = elsize;
+        self->alignment = alignment;
+    }
 
-        self->hasobject = dtypeflags;
-        if (version < 3) {
-                self->hasobject = _descr_find_object(self);
-        }
-        Py_INCREF(Py_None);
-        return Py_None;
+    self->hasobject = dtypeflags;
+    if (version < 3) {
+        self->hasobject = _descr_find_object(self);
+    }
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
 /* returns a copy of the PyArray_Descr structure with the byteorder
    altered:
-    no arguments:  The byteorder is swapped (in all subfields as well)
-    single argument:  The byteorder is forced to the given state
-                      (in all subfields as well)
+   no arguments:  The byteorder is swapped (in all subfields as well)
+   single argument:  The byteorder is forced to the given state
+   (in all subfields as well)
 
-                      Valid states:  ('big', '>') or ('little' or '<')
-                                     ('native', or '=')
+   Valid states:  ('big', '>') or ('little' or '<')
+   ('native', or '=')
 
-                   If a descr structure with | is encountered it's own
-                   byte-order is not changed but any fields are:
+   If a descr structure with | is encountered it's own
+   byte-order is not changed but any fields are:
 */
 
 /*OBJECT_API
   Deep bytorder change of a data-type descriptor
   *** Leaves reference count of self unchanged --- does not DECREF self ***
-*/
+  */
 static PyArray_Descr *
 PyArray_DescrNewByteorder(PyArray_Descr *self, char newendian)
 {
-        PyArray_Descr *new;
-        char endian;
-
-        new = PyArray_DescrNew(self);
-        endian = new->byteorder;
-        if (endian != PyArray_IGNORE) {
-                if (newendian == PyArray_SWAP) {  /* swap byteorder */
-                        if PyArray_ISNBO(endian) endian = PyArray_OPPBYTE;
-                        else endian = PyArray_NATBYTE;
-                        new->byteorder = endian;
-                }
-                else if (newendian != PyArray_IGNORE) {
-                        new->byteorder = newendian;
-                }
+    PyArray_Descr *new;
+    char endian;
+
+    new = PyArray_DescrNew(self);
+    endian = new->byteorder;
+    if (endian != PyArray_IGNORE) {
+        if (newendian == PyArray_SWAP) {  /* swap byteorder */
+            if PyArray_ISNBO(endian) endian = PyArray_OPPBYTE;
+            else endian = PyArray_NATBYTE;
+            new->byteorder = endian;
         }
-        if (new->names) {
-                PyObject *newfields;
-                PyObject *key, *value;
-                PyObject *newvalue;
-                PyObject *old;
-                PyArray_Descr *newdescr;
-                Py_ssize_t pos = 0;
-                int len, i;
-                newfields = PyDict_New();
-                /* make new dictionary with replaced */
-                /* PyArray_Descr Objects */
-                while(PyDict_Next(self->fields, &pos, &key, &value)) {
-                        if (!PyString_Check(key) ||          \
-                            !PyTuple_Check(value) ||                    \
-                            ((len=PyTuple_GET_SIZE(value)) < 2))
-                                continue;
-
-                        old = PyTuple_GET_ITEM(value, 0);
-                        if (!PyArray_DescrCheck(old)) continue;
-                        newdescr = PyArray_DescrNewByteorder            \
-                                ((PyArray_Descr *)old, newendian);
-                        if (newdescr == NULL) {
-                                Py_DECREF(newfields); Py_DECREF(new);
-                                return NULL;
-                        }
-                        newvalue = PyTuple_New(len);
-                        PyTuple_SET_ITEM(newvalue, 0,           \
-                                         (PyObject *)newdescr);
-                        for(i=1; i<len; i++) {
-                                old = PyTuple_GET_ITEM(value, i);
-                                Py_INCREF(old);
-                                PyTuple_SET_ITEM(newvalue, i, old);
-                        }
-                        PyDict_SetItem(newfields, key, newvalue);
-                        Py_DECREF(newvalue);
-                }
-                Py_DECREF(new->fields);
-                new->fields = newfields;
+        else if (newendian != PyArray_IGNORE) {
+            new->byteorder = newendian;
         }
-        if (new->subarray) {
-                Py_DECREF(new->subarray->base);
-                new->subarray->base = PyArray_DescrNewByteorder \
-                        (self->subarray->base, newendian);
+    }
+    if (new->names) {
+        PyObject *newfields;
+        PyObject *key, *value;
+        PyObject *newvalue;
+        PyObject *old;
+        PyArray_Descr *newdescr;
+        Py_ssize_t pos = 0;
+        int len, i;
+        newfields = PyDict_New();
+        /* make new dictionary with replaced */
+        /* PyArray_Descr Objects */
+        while(PyDict_Next(self->fields, &pos, &key, &value)) {
+            if (!PyString_Check(key) ||          \
+                !PyTuple_Check(value) ||                    \
+                ((len=PyTuple_GET_SIZE(value)) < 2))
+                continue;
+
+            old = PyTuple_GET_ITEM(value, 0);
+            if (!PyArray_DescrCheck(old)) continue;
+            newdescr = PyArray_DescrNewByteorder            \
+                ((PyArray_Descr *)old, newendian);
+            if (newdescr == NULL) {
+                Py_DECREF(newfields); Py_DECREF(new);
+                return NULL;
+            }
+            newvalue = PyTuple_New(len);
+            PyTuple_SET_ITEM(newvalue, 0,           \
+                             (PyObject *)newdescr);
+            for(i=1; i<len; i++) {
+                old = PyTuple_GET_ITEM(value, i);
+                Py_INCREF(old);
+                PyTuple_SET_ITEM(newvalue, i, old);
+            }
+            PyDict_SetItem(newfields, key, newvalue);
+            Py_DECREF(newvalue);
         }
-        return new;
+        Py_DECREF(new->fields);
+        new->fields = newfields;
+    }
+    if (new->subarray) {
+        Py_DECREF(new->subarray->base);
+        new->subarray->base = PyArray_DescrNewByteorder \
+            (self->subarray->base, newendian);
+    }
+    return new;
 }
 
 
 static PyObject *
 arraydescr_newbyteorder(PyArray_Descr *self, PyObject *args)
 {
-        char endian=PyArray_SWAP;
+    char endian=PyArray_SWAP;
 
-        if (!PyArg_ParseTuple(args, "|O&", PyArray_ByteorderConverter,
-                              &endian)) return NULL;
+    if (!PyArg_ParseTuple(args, "|O&", PyArray_ByteorderConverter,
+                          &endian)) return NULL;
 
-        return (PyObject *)PyArray_DescrNewByteorder(self, endian);
+    return (PyObject *)PyArray_DescrNewByteorder(self, endian);
 }
 
 static PyMethodDef arraydescr_methods[] = {
-        /* for pickling */
-        {"__reduce__", (PyCFunction)arraydescr_reduce, METH_VARARGS,
-         NULL},
-        {"__setstate__", (PyCFunction)arraydescr_setstate, METH_VARARGS,
-         NULL},
-        {"newbyteorder", (PyCFunction)arraydescr_newbyteorder, METH_VARARGS,
-         NULL},
-        {NULL,          NULL}           /* sentinel */
+    /* for pickling */
+    {"__reduce__", (PyCFunction)arraydescr_reduce, METH_VARARGS,
+     NULL},
+    {"__setstate__", (PyCFunction)arraydescr_setstate, METH_VARARGS,
+     NULL},
+    {"newbyteorder", (PyCFunction)arraydescr_newbyteorder, METH_VARARGS,
+     NULL},
+    {NULL,          NULL}           /* sentinel */
 };
 
 static PyObject *
 arraydescr_str(PyArray_Descr *self)
 {
-        PyObject *sub;
-
-        if (self->names) {
-                PyObject *lst;
-                lst = arraydescr_protocol_descr_get(self);
-                if (!lst) {
-                        sub = PyString_FromString("<err>");
-                        PyErr_Clear();
-                }
-                else sub = PyObject_Str(lst);
-                Py_XDECREF(lst);
-                if (self->type_num != PyArray_VOID) {
-                        PyObject *p;
-                        PyObject *t=PyString_FromString("'");
-                        p = arraydescr_protocol_typestr_get(self);
-                        PyString_Concat(&p, t);
-                        PyString_ConcatAndDel(&t, p);
-                        p = PyString_FromString("(");
-                        PyString_ConcatAndDel(&p, t);
-                        PyString_ConcatAndDel(&p, PyString_FromString(", "));
-                        PyString_ConcatAndDel(&p, sub);
-                        PyString_ConcatAndDel(&p, PyString_FromString(")"));
-                        sub = p;
-                }
-        }
-        else if (self->subarray) {
-                PyObject *p;
-                PyObject *t = PyString_FromString("(");
-                PyObject *sh;
-                p = arraydescr_str(self->subarray->base);
-                if (!self->subarray->base->names && !self->subarray->base->subarray) {
-                        PyObject *t=PyString_FromString("'");
-                        PyString_Concat(&p, t);
-                        PyString_ConcatAndDel(&t, p);
-                        p = t;
-                }
-                PyString_ConcatAndDel(&t, p);
-                PyString_ConcatAndDel(&t, PyString_FromString(","));
-                if (!PyTuple_Check(self->subarray->shape)) {
-                        sh = Py_BuildValue("(O)", self->subarray->shape);
-                }
-                else {
-                        sh = self->subarray->shape;
-                        Py_INCREF(sh);
-                }
-                PyString_ConcatAndDel(&t, PyObject_Str(sh));
-                Py_DECREF(sh);
-                PyString_ConcatAndDel(&t, PyString_FromString(")"));
-                sub = t;
+    PyObject *sub;
+
+    if (self->names) {
+        PyObject *lst;
+        lst = arraydescr_protocol_descr_get(self);
+        if (!lst) {
+            sub = PyString_FromString("<err>");
+            PyErr_Clear();
+        }
+        else sub = PyObject_Str(lst);
+        Py_XDECREF(lst);
+        if (self->type_num != PyArray_VOID) {
+            PyObject *p;
+            PyObject *t=PyString_FromString("'");
+            p = arraydescr_protocol_typestr_get(self);
+            PyString_Concat(&p, t);
+            PyString_ConcatAndDel(&t, p);
+            p = PyString_FromString("(");
+            PyString_ConcatAndDel(&p, t);
+            PyString_ConcatAndDel(&p, PyString_FromString(", "));
+            PyString_ConcatAndDel(&p, sub);
+            PyString_ConcatAndDel(&p, PyString_FromString(")"));
+            sub = p;
         }
-        else if (PyDataType_ISFLEXIBLE(self) || !PyArray_ISNBO(self->byteorder)) {
-                sub = arraydescr_protocol_typestr_get(self);
+    }
+    else if (self->subarray) {
+        PyObject *p;
+        PyObject *t = PyString_FromString("(");
+        PyObject *sh;
+        p = arraydescr_str(self->subarray->base);
+        if (!self->subarray->base->names && !self->subarray->base->subarray) {
+            PyObject *t=PyString_FromString("'");
+            PyString_Concat(&p, t);
+            PyString_ConcatAndDel(&t, p);
+            p = t;
+        }
+        PyString_ConcatAndDel(&t, p);
+        PyString_ConcatAndDel(&t, PyString_FromString(","));
+        if (!PyTuple_Check(self->subarray->shape)) {
+            sh = Py_BuildValue("(O)", self->subarray->shape);
         }
         else {
-                sub = arraydescr_typename_get(self);
+            sh = self->subarray->shape;
+            Py_INCREF(sh);
         }
-        return sub;
+        PyString_ConcatAndDel(&t, PyObject_Str(sh));
+        Py_DECREF(sh);
+        PyString_ConcatAndDel(&t, PyString_FromString(")"));
+        sub = t;
+    }
+    else if (PyDataType_ISFLEXIBLE(self) || !PyArray_ISNBO(self->byteorder)) {
+        sub = arraydescr_protocol_typestr_get(self);
+    }
+    else {
+        sub = arraydescr_typename_get(self);
+    }
+    return sub;
 }
 
 static PyObject *
 arraydescr_repr(PyArray_Descr *self)
 {
-        PyObject *sub, *s;
-        s = PyString_FromString("dtype(");
-        sub = arraydescr_str(self);
-        if (!self->names && !self->subarray) {
-                PyObject *t=PyString_FromString("'");
-                PyString_Concat(&sub, t);
-                PyString_ConcatAndDel(&t, sub);
-                sub = t;
-        }
-        PyString_ConcatAndDel(&s, sub);
-        sub = PyString_FromString(")");
-        PyString_ConcatAndDel(&s, sub);
-        return s;
+    PyObject *sub, *s;
+    s = PyString_FromString("dtype(");
+    sub = arraydescr_str(self);
+    if (!self->names && !self->subarray) {
+        PyObject *t=PyString_FromString("'");
+        PyString_Concat(&sub, t);
+        PyString_ConcatAndDel(&t, sub);
+        sub = t;
+    }
+    PyString_ConcatAndDel(&s, sub);
+    sub = PyString_FromString(")");
+    PyString_ConcatAndDel(&s, sub);
+    return s;
 }
 
 static PyObject *
 arraydescr_richcompare(PyArray_Descr *self, PyObject *other, int cmp_op)
 {
-        PyArray_Descr *new=NULL;
-        PyObject *result = Py_NotImplemented;
-        if (!PyArray_DescrCheck(other)) {
-                if (PyArray_DescrConverter(other, &new) == PY_FAIL)
-                        return NULL;
-        }
-        else {
-                new = (PyArray_Descr *)other;
-                Py_INCREF(new);
-        }
-        switch (cmp_op) {
-        case Py_LT:
-                if (!PyArray_EquivTypes(self, new) && PyArray_CanCastTo(self, new))
-                        result = Py_True;
-                else
-                        result = Py_False;
-                break;
-        case Py_LE:
-                if (PyArray_CanCastTo(self, new))
-                        result = Py_True;
-                else
-                        result = Py_False;
-                break;
-        case Py_EQ:
-                if (PyArray_EquivTypes(self, new))
-                        result = Py_True;
-                else
-                        result = Py_False;
-                break;
-        case Py_NE:
-                if (PyArray_EquivTypes(self, new))
-                        result = Py_False;
-                else
-                        result = Py_True;
-                break;
-        case Py_GT:
-                if (!PyArray_EquivTypes(self, new) && PyArray_CanCastTo(new, self))
-                        result = Py_True;
-                else
-                        result = Py_False;
-                break;
-        case Py_GE:
-                if (PyArray_CanCastTo(new, self))
-                        result = Py_True;
-                else
-                        result = Py_False;
-                break;
-        default:
-                result = Py_NotImplemented;
-        }
+    PyArray_Descr *new=NULL;
+    PyObject *result = Py_NotImplemented;
+    if (!PyArray_DescrCheck(other)) {
+        if (PyArray_DescrConverter(other, &new) == PY_FAIL)
+            return NULL;
+    }
+    else {
+        new = (PyArray_Descr *)other;
+        Py_INCREF(new);
+    }
+    switch (cmp_op) {
+    case Py_LT:
+        if (!PyArray_EquivTypes(self, new) && PyArray_CanCastTo(self, new))
+            result = Py_True;
+        else
+            result = Py_False;
+        break;
+    case Py_LE:
+        if (PyArray_CanCastTo(self, new))
+            result = Py_True;
+        else
+            result = Py_False;
+        break;
+    case Py_EQ:
+        if (PyArray_EquivTypes(self, new))
+            result = Py_True;
+        else
+            result = Py_False;
+        break;
+    case Py_NE:
+        if (PyArray_EquivTypes(self, new))
+            result = Py_False;
+        else
+            result = Py_True;
+        break;
+    case Py_GT:
+        if (!PyArray_EquivTypes(self, new) && PyArray_CanCastTo(new, self))
+            result = Py_True;
+        else
+            result = Py_False;
+        break;
+    case Py_GE:
+        if (PyArray_CanCastTo(new, self))
+            result = Py_True;
+        else
+            result = Py_False;
+        break;
+    default:
+        result = Py_NotImplemented;
+    }
 
-        Py_XDECREF(new);
-        Py_INCREF(result);
-        return result;
+    Py_XDECREF(new);
+    Py_INCREF(result);
+    return result;
 }
 
 /*************************************************************************
@@ -11500,194 +11499,194 @@ static Py_ssize_t
 descr_length(PyObject *self0)
 {
 
-        PyArray_Descr *self = (PyArray_Descr *)self0;
+    PyArray_Descr *self = (PyArray_Descr *)self0;
 
-        if (self->names)
-                return PyTuple_GET_SIZE(self->names);
-        else return 0;
+    if (self->names)
+        return PyTuple_GET_SIZE(self->names);
+    else return 0;
 }
 
 static PyObject *
 descr_repeat(PyObject *self, Py_ssize_t length)
 {
-        PyObject *tup;
-        PyArray_Descr *new;
-        if (length < 0)
-                return PyErr_Format(PyExc_ValueError,
+    PyObject *tup;
+    PyArray_Descr *new;
+    if (length < 0)
+        return PyErr_Format(PyExc_ValueError,
 #if (PY_VERSION_HEX < 0x02050000)
-                                    "Array length must be >= 0, not %d",
+                            "Array length must be >= 0, not %d",
 #else
-                                    "Array length must be >= 0, not %zd",
+                            "Array length must be >= 0, not %zd",
 #endif
-                                    length);
-        tup = Py_BuildValue("O" NPY_SSIZE_T_PYFMT, self, length);
-        if (tup == NULL) return NULL;
-        PyArray_DescrConverter(tup, &new);
-        Py_DECREF(tup);
-        return (PyObject *)new;
+                            length);
+    tup = Py_BuildValue("O" NPY_SSIZE_T_PYFMT, self, length);
+    if (tup == NULL) return NULL;
+    PyArray_DescrConverter(tup, &new);
+    Py_DECREF(tup);
+    return (PyObject *)new;
 }
 
 static PyObject *
 descr_subscript(PyArray_Descr *self, PyObject *op)
 {
 
-        if (self->names) {
-                if (PyString_Check(op) || PyUnicode_Check(op)) {
-                        PyObject *obj;
-                        obj = PyDict_GetItem(self->fields, op);
-                        if (obj != NULL) {
-                                PyObject *descr;
-                                descr = PyTuple_GET_ITEM(obj, 0);
-                                Py_INCREF(descr);
-                                return descr;
-                        }
-                        else {
-                                PyErr_Format(PyExc_KeyError,
-                                             "field named \'%s\' not found.",
-                                             PyString_AsString(op));
-                        }
-                }
-                else {
-                        PyObject *name;
-                        int value;
-                        value = PyArray_PyIntAsInt(op);
-                        if (!PyErr_Occurred()) {
-                                int size;
-                                size = PyTuple_GET_SIZE(self->names);
-                                if (value < 0) value += size;
-                                if (value < 0 || value >= size) {
-                                        PyErr_Format(PyExc_IndexError,
-                                                     "0<=index<%d not %d",
-                                                     size, value);
-                                        return NULL;
-                                }
-                                name = PyTuple_GET_ITEM(self->names, value);
-                                return descr_subscript(self, name);
-                        }
-                }
-                PyErr_SetString(PyExc_ValueError,
-                                "only integers, strings or unicode values "
-                                "allowed for getting fields.");
+    if (self->names) {
+        if (PyString_Check(op) || PyUnicode_Check(op)) {
+            PyObject *obj;
+            obj = PyDict_GetItem(self->fields, op);
+            if (obj != NULL) {
+                PyObject *descr;
+                descr = PyTuple_GET_ITEM(obj, 0);
+                Py_INCREF(descr);
+                return descr;
+            }
+            else {
+                PyErr_Format(PyExc_KeyError,
+                             "field named \'%s\' not found.",
+                             PyString_AsString(op));
+            }
         }
         else {
-                PyObject *astr;
-                astr = arraydescr_str(self);
-                PyErr_Format(PyExc_KeyError,
-                             "there are no fields in dtype %s.",
-                             PyString_AsString(astr));
-                Py_DECREF(astr);
+            PyObject *name;
+            int value;
+            value = PyArray_PyIntAsInt(op);
+            if (!PyErr_Occurred()) {
+                int size;
+                size = PyTuple_GET_SIZE(self->names);
+                if (value < 0) value += size;
+                if (value < 0 || value >= size) {
+                    PyErr_Format(PyExc_IndexError,
+                                 "0<=index<%d not %d",
+                                 size, value);
+                    return NULL;
+                }
+                name = PyTuple_GET_ITEM(self->names, value);
+                return descr_subscript(self, name);
+            }
         }
-        return NULL;
+        PyErr_SetString(PyExc_ValueError,
+                        "only integers, strings or unicode values "
+                        "allowed for getting fields.");
+    }
+    else {
+        PyObject *astr;
+        astr = arraydescr_str(self);
+        PyErr_Format(PyExc_KeyError,
+                     "there are no fields in dtype %s.",
+                     PyString_AsString(astr));
+        Py_DECREF(astr);
+    }
+    return NULL;
 }
 
 static PySequenceMethods descr_as_sequence = {
-        descr_length,
-        (binaryfunc)NULL,
-        descr_repeat,
+    descr_length,
+    (binaryfunc)NULL,
+    descr_repeat,
 };
 
 static PyMappingMethods descr_as_mapping = {
-        descr_length,                       /*mp_length*/
-        (binaryfunc)descr_subscript,        /*mp_subscript*/
-        (objobjargproc)NULL,                /*mp_ass_subscript*/
+    descr_length,                       /*mp_length*/
+    (binaryfunc)descr_subscript,        /*mp_subscript*/
+    (objobjargproc)NULL,                /*mp_ass_subscript*/
 };
 
 /****************** End of Mapping Protocol ******************************/
 
 
 static PyTypeObject PyArrayDescr_Type = {
-        PyObject_HEAD_INIT(NULL)
-        0,                                       /* ob_size */
-        "numpy.dtype",                           /* tp_name */
-        sizeof(PyArray_Descr),                   /* tp_basicsize */
-        0,                                       /* tp_itemsize */
-        /* methods */
-        (destructor)arraydescr_dealloc,         /* tp_dealloc */
-        0,                                      /* tp_print */
-        0,                                      /* tp_getattr */
-        0,                                      /* tp_setattr */
-        0,                                      /* tp_compare */
-        (reprfunc)arraydescr_repr,              /* tp_repr */
-        0,                                      /* tp_as_number */
-        &descr_as_sequence,                     /* tp_as_sequence */
-        &descr_as_mapping,                      /* tp_as_mapping */
-        0,                                      /* tp_hash */
-        0,                                      /* tp_call */
-        (reprfunc)arraydescr_str,               /* tp_str */
-        0,                                      /* tp_getattro */
-        0,                                      /* tp_setattro */
-        0,                                      /* tp_as_buffer */
-        Py_TPFLAGS_DEFAULT,                     /* tp_flags */
-        0,                                      /* tp_doc */
-        0,                                      /* tp_traverse */
-        0,                                      /* tp_clear */
-        (richcmpfunc)arraydescr_richcompare,    /* tp_richcompare */
-        0,                                      /* tp_weaklistoffset */
-        0,                                      /* tp_iter */
-        0,                                      /* tp_iternext */
-        arraydescr_methods,                     /* tp_methods */
-        arraydescr_members,                     /* tp_members */
-        arraydescr_getsets,                     /* tp_getset */
-        0,                                        /* tp_base */
-        0,                                        /* tp_dict */
-        0,                                        /* tp_descr_get */
-        0,                                        /* tp_descr_set */
-        0,                                        /* tp_dictoffset */
-        0,                                        /* tp_init */
-        0,                                        /* tp_alloc */
-        arraydescr_new,                           /* tp_new */
-        0,                                        /* tp_free */
-        0,                                        /* tp_is_gc */
-        0,                                        /* tp_bases */
-        0,                                        /* tp_mro */
-        0,                                        /* tp_cache */
-        0,                                        /* tp_subclasses */
-        0                                         /* tp_weaklist */
+    PyObject_HEAD_INIT(NULL)
+    0,                                       /* ob_size */
+    "numpy.dtype",                           /* tp_name */
+    sizeof(PyArray_Descr),                   /* tp_basicsize */
+    0,                                       /* tp_itemsize */
+    /* methods */
+    (destructor)arraydescr_dealloc,         /* tp_dealloc */
+    0,                                      /* tp_print */
+    0,                                      /* tp_getattr */
+    0,                                      /* tp_setattr */
+    0,                                      /* tp_compare */
+    (reprfunc)arraydescr_repr,              /* tp_repr */
+    0,                                      /* tp_as_number */
+    &descr_as_sequence,                     /* tp_as_sequence */
+    &descr_as_mapping,                      /* tp_as_mapping */
+    0,                                      /* tp_hash */
+    0,                                      /* tp_call */
+    (reprfunc)arraydescr_str,               /* tp_str */
+    0,                                      /* tp_getattro */
+    0,                                      /* tp_setattro */
+    0,                                      /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                     /* tp_flags */
+    0,                                      /* tp_doc */
+    0,                                      /* tp_traverse */
+    0,                                      /* tp_clear */
+    (richcmpfunc)arraydescr_richcompare,    /* tp_richcompare */
+    0,                                      /* tp_weaklistoffset */
+    0,                                      /* tp_iter */
+    0,                                      /* tp_iternext */
+    arraydescr_methods,                     /* tp_methods */
+    arraydescr_members,                     /* tp_members */
+    arraydescr_getsets,                     /* tp_getset */
+    0,                                        /* tp_base */
+    0,                                        /* tp_dict */
+    0,                                        /* tp_descr_get */
+    0,                                        /* tp_descr_set */
+    0,                                        /* tp_dictoffset */
+    0,                                        /* tp_init */
+    0,                                        /* tp_alloc */
+    arraydescr_new,                           /* tp_new */
+    0,                                        /* tp_free */
+    0,                                        /* tp_is_gc */
+    0,                                        /* tp_bases */
+    0,                                        /* tp_mro */
+    0,                                        /* tp_cache */
+    0,                                        /* tp_subclasses */
+    0                                         /* tp_weaklist */
 };
 
 
 /** Array Flags Object **/
 
 /*OBJECT_API
- Get New ArrayFlagsObject
+  Get New ArrayFlagsObject
 */
 static PyObject *
 PyArray_NewFlagsObject(PyObject *obj)
 {
-        PyObject *flagobj;
-        int flags;
-        if (obj == NULL) {
-                flags = CONTIGUOUS | OWNDATA | FORTRAN | ALIGNED;
-        }
-        else {
-                flags = PyArray_FLAGS(obj);
-        }
-        flagobj = PyArrayFlags_Type.tp_alloc(&PyArrayFlags_Type, 0);
-        if (flagobj == NULL) return NULL;
-        Py_XINCREF(obj);
-        ((PyArrayFlagsObject *)flagobj)->arr = obj;
-        ((PyArrayFlagsObject *)flagobj)->flags = flags;
+    PyObject *flagobj;
+    int flags;
+    if (obj == NULL) {
+        flags = CONTIGUOUS | OWNDATA | FORTRAN | ALIGNED;
+    }
+    else {
+        flags = PyArray_FLAGS(obj);
+    }
+    flagobj = PyArrayFlags_Type.tp_alloc(&PyArrayFlags_Type, 0);
+    if (flagobj == NULL) return NULL;
+    Py_XINCREF(obj);
+    ((PyArrayFlagsObject *)flagobj)->arr = obj;
+    ((PyArrayFlagsObject *)flagobj)->flags = flags;
 
-        return flagobj;
+    return flagobj;
 }
 
 static void
 arrayflags_dealloc(PyArrayFlagsObject *self)
 {
-        Py_XDECREF(self->arr);
-        self->ob_type->tp_free((PyObject *)self);
+    Py_XDECREF(self->arr);
+    self->ob_type->tp_free((PyObject *)self);
 }
 
 
-#define _define_get(UPPER, lower)                 \
-static PyObject * \
-arrayflags_ ## lower ## _get(PyArrayFlagsObject *self) \
-{ \
-        PyObject *item; \
+#define _define_get(UPPER, lower)                                       \
+    static PyObject *                                                   \
+    arrayflags_ ## lower ## _get(PyArrayFlagsObject *self)              \
+    {                                                                   \
+        PyObject *item;                                                 \
         item = ((self->flags & (UPPER)) == (UPPER)) ? Py_True : Py_False; \
-        Py_INCREF(item); \
-        return item; \
-}
+        Py_INCREF(item);                                                \
+        return item;                                                    \
+    }
 
 _define_get(CONTIGUOUS, contiguous)
 _define_get(FORTRAN, fortran)
@@ -11702,375 +11701,375 @@ _define_get(ALIGNED|WRITEABLE|CONTIGUOUS, carray)
 static PyObject *
 arrayflags_forc_get(PyArrayFlagsObject *self)
 {
-        PyObject *item;
+    PyObject *item;
 
-        if (((self->flags & FORTRAN) == FORTRAN) ||
-            ((self->flags & CONTIGUOUS) == CONTIGUOUS))
-                item = Py_True;
-        else
-                item = Py_False;
+    if (((self->flags & FORTRAN) == FORTRAN) ||
+        ((self->flags & CONTIGUOUS) == CONTIGUOUS))
+        item = Py_True;
+    else
+        item = Py_False;
 
-        Py_INCREF(item);
-        return item;
+    Py_INCREF(item);
+    return item;
 }
 
 static PyObject *
 arrayflags_fnc_get(PyArrayFlagsObject *self)
 {
-        PyObject *item;
+    PyObject *item;
 
-        if (((self->flags & FORTRAN) == FORTRAN) &&
-            !((self->flags & CONTIGUOUS) == CONTIGUOUS))
-                item = Py_True;
-        else
-                item = Py_False;
+    if (((self->flags & FORTRAN) == FORTRAN) &&
+        !((self->flags & CONTIGUOUS) == CONTIGUOUS))
+        item = Py_True;
+    else
+        item = Py_False;
 
-        Py_INCREF(item);
-        return item;
+    Py_INCREF(item);
+    return item;
 }
 
 static PyObject *
 arrayflags_farray_get(PyArrayFlagsObject *self)
 {
-        PyObject *item;
+    PyObject *item;
 
-        if (((self->flags & (ALIGNED|WRITEABLE|FORTRAN)) ==     \
-             (ALIGNED|WRITEABLE|FORTRAN)) &&
-            !((self->flags & CONTIGUOUS) == CONTIGUOUS))
-                item = Py_True;
-        else
-                item = Py_False;
+    if (((self->flags & (ALIGNED|WRITEABLE|FORTRAN)) ==     \
+         (ALIGNED|WRITEABLE|FORTRAN)) &&
+        !((self->flags & CONTIGUOUS) == CONTIGUOUS))
+        item = Py_True;
+    else
+        item = Py_False;
 
-        Py_INCREF(item);
-        return item;
+    Py_INCREF(item);
+    return item;
 }
 
 static PyObject *
 arrayflags_num_get(PyArrayFlagsObject *self)
 {
-        return PyInt_FromLong(self->flags);
+    return PyInt_FromLong(self->flags);
 }
 
 /* relies on setflags order being write, align, uic */
 static int
 arrayflags_updateifcopy_set(PyArrayFlagsObject *self, PyObject *obj)
 {
-        PyObject *res;
-        if (self->arr == NULL) {
-                PyErr_SetString(PyExc_ValueError, "Cannot set flags on array scalars.");
-                return -1;
-        }
-        res = PyObject_CallMethod(self->arr, "setflags", "OOO", Py_None, Py_None,
-                                  (PyObject_IsTrue(obj) ? Py_True : Py_False));
-        if (res == NULL) return -1;
-        Py_DECREF(res);
-        return 0;
+    PyObject *res;
+    if (self->arr == NULL) {
+        PyErr_SetString(PyExc_ValueError, "Cannot set flags on array scalars.");
+        return -1;
+    }
+    res = PyObject_CallMethod(self->arr, "setflags", "OOO", Py_None, Py_None,
+                              (PyObject_IsTrue(obj) ? Py_True : Py_False));
+    if (res == NULL) return -1;
+    Py_DECREF(res);
+    return 0;
 }
 
 static int
 arrayflags_aligned_set(PyArrayFlagsObject *self, PyObject *obj)
 {
-        PyObject *res;
-        if (self->arr == NULL) {
-                PyErr_SetString(PyExc_ValueError, "Cannot set flags on array scalars.");
-                return -1;
-        }
-        res = PyObject_CallMethod(self->arr, "setflags", "OOO", Py_None,
-                                  (PyObject_IsTrue(obj) ? Py_True : Py_False),
-                                  Py_None);
-        if (res == NULL) return -1;
-        Py_DECREF(res);
-        return 0;
+    PyObject *res;
+    if (self->arr == NULL) {
+        PyErr_SetString(PyExc_ValueError, "Cannot set flags on array scalars.");
+        return -1;
+    }
+    res = PyObject_CallMethod(self->arr, "setflags", "OOO", Py_None,
+                              (PyObject_IsTrue(obj) ? Py_True : Py_False),
+                              Py_None);
+    if (res == NULL) return -1;
+    Py_DECREF(res);
+    return 0;
 }
 
 static int
 arrayflags_writeable_set(PyArrayFlagsObject *self, PyObject *obj)
 {
-        PyObject *res;
-        if (self->arr == NULL) {
-                PyErr_SetString(PyExc_ValueError, "Cannot set flags on array scalars.");
-                return -1;
-        }
-        res = PyObject_CallMethod(self->arr, "setflags", "OOO",
-                                  (PyObject_IsTrue(obj) ? Py_True : Py_False),
-                                   Py_None, Py_None);
-        if (res == NULL) return -1;
-        Py_DECREF(res);
-        return 0;
+    PyObject *res;
+    if (self->arr == NULL) {
+        PyErr_SetString(PyExc_ValueError, "Cannot set flags on array scalars.");
+        return -1;
+    }
+    res = PyObject_CallMethod(self->arr, "setflags", "OOO",
+                              (PyObject_IsTrue(obj) ? Py_True : Py_False),
+                              Py_None, Py_None);
+    if (res == NULL) return -1;
+    Py_DECREF(res);
+    return 0;
 }
 
 
 static PyGetSetDef arrayflags_getsets[] = {
-        {"contiguous",
-         (getter)arrayflags_contiguous_get,
-         NULL,
-         ""},
-        {"c_contiguous",
-         (getter)arrayflags_contiguous_get,
-         NULL,
-         ""},
-        {"f_contiguous",
-         (getter)arrayflags_fortran_get,
-         NULL,
-         ""},
-        {"fortran",
-         (getter)arrayflags_fortran_get,
-         NULL,
-         ""},
-        {"updateifcopy",
-         (getter)arrayflags_updateifcopy_get,
-         (setter)arrayflags_updateifcopy_set,
-         ""},
-        {"owndata",
-         (getter)arrayflags_owndata_get,
-         NULL,
-         ""},
-        {"aligned",
-         (getter)arrayflags_aligned_get,
-         (setter)arrayflags_aligned_set,
-         ""},
-        {"writeable",
-         (getter)arrayflags_writeable_get,
-         (setter)arrayflags_writeable_set,
-         ""},
-        {"fnc",
-         (getter)arrayflags_fnc_get,
-         NULL,
-         ""},
-        {"forc",
-         (getter)arrayflags_forc_get,
-         NULL,
-         ""},
-        {"behaved",
-         (getter)arrayflags_behaved_get,
-         NULL,
-         ""},
-        {"carray",
-         (getter)arrayflags_carray_get,
-         NULL,
-         ""},
-        {"farray",
-         (getter)arrayflags_farray_get,
-         NULL,
-         ""},
-        {"num",
-         (getter)arrayflags_num_get,
-         NULL,
-         ""},
-        {NULL, NULL, NULL, NULL},
+    {"contiguous",
+     (getter)arrayflags_contiguous_get,
+     NULL,
+     ""},
+    {"c_contiguous",
+     (getter)arrayflags_contiguous_get,
+     NULL,
+     ""},
+    {"f_contiguous",
+     (getter)arrayflags_fortran_get,
+     NULL,
+     ""},
+    {"fortran",
+     (getter)arrayflags_fortran_get,
+     NULL,
+     ""},
+    {"updateifcopy",
+     (getter)arrayflags_updateifcopy_get,
+     (setter)arrayflags_updateifcopy_set,
+     ""},
+    {"owndata",
+     (getter)arrayflags_owndata_get,
+     NULL,
+     ""},
+    {"aligned",
+     (getter)arrayflags_aligned_get,
+     (setter)arrayflags_aligned_set,
+     ""},
+    {"writeable",
+     (getter)arrayflags_writeable_get,
+     (setter)arrayflags_writeable_set,
+     ""},
+    {"fnc",
+     (getter)arrayflags_fnc_get,
+     NULL,
+     ""},
+    {"forc",
+     (getter)arrayflags_forc_get,
+     NULL,
+     ""},
+    {"behaved",
+     (getter)arrayflags_behaved_get,
+     NULL,
+     ""},
+    {"carray",
+     (getter)arrayflags_carray_get,
+     NULL,
+     ""},
+    {"farray",
+     (getter)arrayflags_farray_get,
+     NULL,
+     ""},
+    {"num",
+     (getter)arrayflags_num_get,
+     NULL,
+     ""},
+    {NULL, NULL, NULL, NULL},
 };
 
 static PyObject *
 arrayflags_getitem(PyArrayFlagsObject *self, PyObject *ind)
 {
-        char *key;
-        int n;
-        if (!PyString_Check(ind)) goto fail;
-        key = PyString_AS_STRING(ind);
-        n = PyString_GET_SIZE(ind);
-        switch(n) {
-        case 1:
-                switch(key[0]) {
-                case 'C':
-                        return arrayflags_contiguous_get(self);
-                case 'F':
-                        return arrayflags_fortran_get(self);
-                case 'W':
-                        return arrayflags_writeable_get(self);
-                case 'B':
-                        return arrayflags_behaved_get(self);
-                case 'O':
-                        return arrayflags_owndata_get(self);
-                case 'A':
-                        return arrayflags_aligned_get(self);
-                case 'U':
-                        return arrayflags_updateifcopy_get(self);
-                default:
-                        goto fail;
-                }
-                break;
-        case 2:
-                if (strncmp(key, "CA", n)==0)
-                        return arrayflags_carray_get(self);
-                if (strncmp(key, "FA", n)==0)
-                        return arrayflags_farray_get(self);
-                break;
-        case 3:
-                if (strncmp(key, "FNC", n)==0)
-                        return arrayflags_fnc_get(self);
-                break;
-        case 4:
-                if (strncmp(key, "FORC", n)==0)
-                        return arrayflags_forc_get(self);
-                break;
-        case 6:
-                if (strncmp(key, "CARRAY", n)==0)
-                        return arrayflags_carray_get(self);
-                if (strncmp(key, "FARRAY", n)==0)
-                        return arrayflags_farray_get(self);
-                break;
-        case 7:
-                if (strncmp(key,"FORTRAN",n)==0)
-                        return arrayflags_fortran_get(self);
-                if (strncmp(key,"BEHAVED",n)==0)
-                        return arrayflags_behaved_get(self);
-                if (strncmp(key,"OWNDATA",n)==0)
-                        return arrayflags_owndata_get(self);
-                if (strncmp(key,"ALIGNED",n)==0)
-                        return arrayflags_aligned_get(self);
-                break;
-        case 9:
-                if (strncmp(key,"WRITEABLE",n)==0)
-                        return arrayflags_writeable_get(self);
-                break;
-        case 10:
-                if (strncmp(key,"CONTIGUOUS",n)==0)
-                        return arrayflags_contiguous_get(self);
-                break;
-        case 12:
-                if (strncmp(key, "UPDATEIFCOPY", n)==0)
-                        return arrayflags_updateifcopy_get(self);
-                if (strncmp(key, "C_CONTIGUOUS", n)==0)
-                        return arrayflags_contiguous_get(self);
-                if (strncmp(key, "F_CONTIGUOUS", n)==0)
-                        return arrayflags_fortran_get(self);
-                break;
-        }
+    char *key;
+    int n;
+    if (!PyString_Check(ind)) goto fail;
+    key = PyString_AS_STRING(ind);
+    n = PyString_GET_SIZE(ind);
+    switch(n) {
+    case 1:
+        switch(key[0]) {
+        case 'C':
+            return arrayflags_contiguous_get(self);
+        case 'F':
+            return arrayflags_fortran_get(self);
+        case 'W':
+            return arrayflags_writeable_get(self);
+        case 'B':
+            return arrayflags_behaved_get(self);
+        case 'O':
+            return arrayflags_owndata_get(self);
+        case 'A':
+            return arrayflags_aligned_get(self);
+        case 'U':
+            return arrayflags_updateifcopy_get(self);
+        default:
+            goto fail;
+        }
+        break;
+    case 2:
+        if (strncmp(key, "CA", n)==0)
+            return arrayflags_carray_get(self);
+        if (strncmp(key, "FA", n)==0)
+            return arrayflags_farray_get(self);
+        break;
+    case 3:
+        if (strncmp(key, "FNC", n)==0)
+            return arrayflags_fnc_get(self);
+        break;
+    case 4:
+        if (strncmp(key, "FORC", n)==0)
+            return arrayflags_forc_get(self);
+        break;
+    case 6:
+        if (strncmp(key, "CARRAY", n)==0)
+            return arrayflags_carray_get(self);
+        if (strncmp(key, "FARRAY", n)==0)
+            return arrayflags_farray_get(self);
+        break;
+    case 7:
+        if (strncmp(key,"FORTRAN",n)==0)
+            return arrayflags_fortran_get(self);
+        if (strncmp(key,"BEHAVED",n)==0)
+            return arrayflags_behaved_get(self);
+        if (strncmp(key,"OWNDATA",n)==0)
+            return arrayflags_owndata_get(self);
+        if (strncmp(key,"ALIGNED",n)==0)
+            return arrayflags_aligned_get(self);
+        break;
+    case 9:
+        if (strncmp(key,"WRITEABLE",n)==0)
+            return arrayflags_writeable_get(self);
+        break;
+    case 10:
+        if (strncmp(key,"CONTIGUOUS",n)==0)
+            return arrayflags_contiguous_get(self);
+        break;
+    case 12:
+        if (strncmp(key, "UPDATEIFCOPY", n)==0)
+            return arrayflags_updateifcopy_get(self);
+        if (strncmp(key, "C_CONTIGUOUS", n)==0)
+            return arrayflags_contiguous_get(self);
+        if (strncmp(key, "F_CONTIGUOUS", n)==0)
+            return arrayflags_fortran_get(self);
+        break;
+    }
 
  fail:
-        PyErr_SetString(PyExc_KeyError, "Unknown flag");
-        return NULL;
+    PyErr_SetString(PyExc_KeyError, "Unknown flag");
+    return NULL;
 }
 
 static int
 arrayflags_setitem(PyArrayFlagsObject *self, PyObject *ind, PyObject *item)
 {
-        char *key;
-        int n;
-        if (!PyString_Check(ind)) goto fail;
-        key = PyString_AS_STRING(ind);
-        n = PyString_GET_SIZE(ind);
-        if (((n==9) && (strncmp(key, "WRITEABLE", n)==0)) ||
-            ((n==1) && (strncmp(key, "W", n)==0)))
-                return arrayflags_writeable_set(self, item);
-        else if (((n==7) && (strncmp(key, "ALIGNED", n)==0)) ||
-                 ((n==1) && (strncmp(key, "A", n)==0)))
-                return arrayflags_aligned_set(self, item);
-        else if (((n==12) && (strncmp(key, "UPDATEIFCOPY", n)==0)) ||
-                 ((n==1) && (strncmp(key, "U", n)==0)))
-                return arrayflags_updateifcopy_set(self, item);
-
-fail:
-        PyErr_SetString(PyExc_KeyError, "Unknown flag");
-        return -1;
+    char *key;
+    int n;
+    if (!PyString_Check(ind)) goto fail;
+    key = PyString_AS_STRING(ind);
+    n = PyString_GET_SIZE(ind);
+    if (((n==9) && (strncmp(key, "WRITEABLE", n)==0)) ||
+        ((n==1) && (strncmp(key, "W", n)==0)))
+        return arrayflags_writeable_set(self, item);
+    else if (((n==7) && (strncmp(key, "ALIGNED", n)==0)) ||
+             ((n==1) && (strncmp(key, "A", n)==0)))
+        return arrayflags_aligned_set(self, item);
+    else if (((n==12) && (strncmp(key, "UPDATEIFCOPY", n)==0)) ||
+             ((n==1) && (strncmp(key, "U", n)==0)))
+        return arrayflags_updateifcopy_set(self, item);
+
+ fail:
+    PyErr_SetString(PyExc_KeyError, "Unknown flag");
+    return -1;
 }
 
 static char *
 _torf_(int flags, int val)
 {
-        if ((flags & val) == val) return "True";
-        else return "False";
+    if ((flags & val) == val) return "True";
+    else return "False";
 }
 
 static PyObject *
 arrayflags_print(PyArrayFlagsObject *self)
 {
-        int fl = self->flags;
+    int fl = self->flags;
 
-        return PyString_FromFormat("  %s : %s\n  %s : %s\n  %s : %s\n"\
-                                   "  %s : %s\n  %s : %s\n  %s : %s",
-                                   "C_CONTIGUOUS", _torf_(fl, CONTIGUOUS),
-                                   "F_CONTIGUOUS", _torf_(fl, FORTRAN),
-                                   "OWNDATA", _torf_(fl, OWNDATA),
-                                   "WRITEABLE", _torf_(fl, WRITEABLE),
-                                   "ALIGNED", _torf_(fl, ALIGNED),
-                                   "UPDATEIFCOPY", _torf_(fl, UPDATEIFCOPY));
+    return PyString_FromFormat("  %s : %s\n  %s : %s\n  %s : %s\n"\
+                               "  %s : %s\n  %s : %s\n  %s : %s",
+                               "C_CONTIGUOUS", _torf_(fl, CONTIGUOUS),
+                               "F_CONTIGUOUS", _torf_(fl, FORTRAN),
+                               "OWNDATA", _torf_(fl, OWNDATA),
+                               "WRITEABLE", _torf_(fl, WRITEABLE),
+                               "ALIGNED", _torf_(fl, ALIGNED),
+                               "UPDATEIFCOPY", _torf_(fl, UPDATEIFCOPY));
 }
 
 
 static int
 arrayflags_compare(PyArrayFlagsObject *self, PyArrayFlagsObject *other)
 {
-        if (self->flags == other->flags)
-                return 0;
-        else if (self->flags < other->flags)
-                return -1;
-        else
-                return 1;
+    if (self->flags == other->flags)
+        return 0;
+    else if (self->flags < other->flags)
+        return -1;
+    else
+        return 1;
 }
 
 static PyMappingMethods arrayflags_as_mapping = {
 #if PY_VERSION_HEX >= 0x02050000
-        (lenfunc)NULL,                       /*mp_length*/
+    (lenfunc)NULL,                       /*mp_length*/
 #else
-        (inquiry)NULL,                       /*mp_length*/
+    (inquiry)NULL,                       /*mp_length*/
 #endif
-        (binaryfunc)arrayflags_getitem,      /*mp_subscript*/
-        (objobjargproc)arrayflags_setitem,   /*mp_ass_subscript*/
+    (binaryfunc)arrayflags_getitem,      /*mp_subscript*/
+    (objobjargproc)arrayflags_setitem,   /*mp_ass_subscript*/
 };
 
 
 static PyObject *
 arrayflags_new(PyTypeObject *self, PyObject *args, PyObject *kwds)
 {
-        PyObject *arg=NULL;
-        if (!PyArg_UnpackTuple(args, "flagsobj", 0, 1, &arg))
-                return NULL;
+    PyObject *arg=NULL;
+    if (!PyArg_UnpackTuple(args, "flagsobj", 0, 1, &arg))
+        return NULL;
 
-        if ((arg != NULL) && PyArray_Check(arg)) {
-                return PyArray_NewFlagsObject(arg);
-        }
-        else {
-                return PyArray_NewFlagsObject(NULL);
-        }
+    if ((arg != NULL) && PyArray_Check(arg)) {
+        return PyArray_NewFlagsObject(arg);
+    }
+    else {
+        return PyArray_NewFlagsObject(NULL);
+    }
 }
 
 static PyTypeObject PyArrayFlags_Type = {
-        PyObject_HEAD_INIT(NULL)
-        0,
-        "numpy.flagsobj",
-        sizeof(PyArrayFlagsObject),
-        0,                                       /* tp_itemsize */
-        /* methods */
-        (destructor)arrayflags_dealloc,         /* tp_dealloc */
-        0,                                      /* tp_print */
-        0,                                      /* tp_getattr */
-        0,                                      /* tp_setattr */
-        (cmpfunc)arrayflags_compare,            /* tp_compare */
-        (reprfunc)arrayflags_print,             /* tp_repr */
-        0,                                      /* tp_as_number */
-        0,                                      /* tp_as_sequence */
-        &arrayflags_as_mapping,                 /* tp_as_mapping */
-        0,                                      /* tp_hash */
-        0,                                      /* tp_call */
-        (reprfunc)arrayflags_print,             /* tp_str */
-        0,                                      /* tp_getattro */
-        0,                                      /* tp_setattro */
-        0,                                      /* tp_as_buffer */
-        Py_TPFLAGS_DEFAULT,                     /* tp_flags */
-        0,                                      /* tp_doc */
-        0,                                      /* tp_traverse */
-        0,                                      /* tp_clear */
-        0,                                      /* tp_richcompare */
-        0,                                      /* tp_weaklistoffset */
-        0,                                      /* tp_iter */
-        0,                                      /* tp_iternext */
-        0,                                       /* tp_methods */
-        0,                                       /* tp_members */
-        arrayflags_getsets,                      /* tp_getset */
-        0,                                        /* tp_base */
-        0,                                        /* tp_dict */
-        0,                                        /* tp_descr_get */
-        0,                                        /* tp_descr_set */
-        0,                                        /* tp_dictoffset */
-        0,                                        /* tp_init */
-        0,                                        /* tp_alloc */
-        arrayflags_new,                           /* tp_new */
-        0,                                        /* tp_free */
-        0,                                        /* tp_is_gc */
-        0,                                        /* tp_bases */
-        0,                                        /* tp_mro */
-        0,                                        /* tp_cache */
-        0,                                        /* tp_subclasses */
-        0                                         /* tp_weaklist */
+    PyObject_HEAD_INIT(NULL)
+    0,
+    "numpy.flagsobj",
+    sizeof(PyArrayFlagsObject),
+    0,                                       /* tp_itemsize */
+    /* methods */
+    (destructor)arrayflags_dealloc,         /* tp_dealloc */
+    0,                                      /* tp_print */
+    0,                                      /* tp_getattr */
+    0,                                      /* tp_setattr */
+    (cmpfunc)arrayflags_compare,            /* tp_compare */
+    (reprfunc)arrayflags_print,             /* tp_repr */
+    0,                                      /* tp_as_number */
+    0,                                      /* tp_as_sequence */
+    &arrayflags_as_mapping,                 /* tp_as_mapping */
+    0,                                      /* tp_hash */
+    0,                                      /* tp_call */
+    (reprfunc)arrayflags_print,             /* tp_str */
+    0,                                      /* tp_getattro */
+    0,                                      /* tp_setattro */
+    0,                                      /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,                     /* tp_flags */
+    0,                                      /* tp_doc */
+    0,                                      /* tp_traverse */
+    0,                                      /* tp_clear */
+    0,                                      /* tp_richcompare */
+    0,                                      /* tp_weaklistoffset */
+    0,                                      /* tp_iter */
+    0,                                      /* tp_iternext */
+    0,                                       /* tp_methods */
+    0,                                       /* tp_members */
+    arrayflags_getsets,                      /* tp_getset */
+    0,                                        /* tp_base */
+    0,                                        /* tp_dict */
+    0,                                        /* tp_descr_get */
+    0,                                        /* tp_descr_set */
+    0,                                        /* tp_dictoffset */
+    0,                                        /* tp_init */
+    0,                                        /* tp_alloc */
+    arrayflags_new,                           /* tp_new */
+    0,                                        /* tp_free */
+    0,                                        /* tp_is_gc */
+    0,                                        /* tp_bases */
+    0,                                        /* tp_mro */
+    0,                                        /* tp_cache */
+    0,                                        /* tp_subclasses */
+    0                                         /* tp_weaklist */
 };