Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 2 of 2.

1 files changed, 847 insertions, 847 deletions

diff --git a/contrib/tools/cython/Cython/Utility/MemoryView_C.c b/contrib/tools/cython/Cython/Utility/MemoryView_C.c
index 44e6fa9d88..0a5d8ee2c2 100644
--- a/contrib/tools/cython/Cython/Utility/MemoryView_C.c
+++ b/contrib/tools/cython/Cython/Utility/MemoryView_C.c
@@ -1,352 +1,352 @@
-////////// MemviewSliceStruct.proto ////////// 
+////////// MemviewSliceStruct.proto //////////
 //@proto_block: utility_code_proto_before_types
- 
-/* memoryview slice struct */ 
-struct {{memview_struct_name}}; 
- 
-typedef struct { 
-  struct {{memview_struct_name}} *memview; 
-  char *data; 
-  Py_ssize_t shape[{{max_dims}}]; 
-  Py_ssize_t strides[{{max_dims}}]; 
-  Py_ssize_t suboffsets[{{max_dims}}]; 
-} {{memviewslice_name}}; 
- 
+
+/* memoryview slice struct */
+struct {{memview_struct_name}};
+
+typedef struct {
+  struct {{memview_struct_name}} *memview;
+  char *data;
+  Py_ssize_t shape[{{max_dims}}];
+  Py_ssize_t strides[{{max_dims}}];
+  Py_ssize_t suboffsets[{{max_dims}}];
+} {{memviewslice_name}};
+
 // used for "len(memviewslice)"
 #define __Pyx_MemoryView_Len(m)  (m.shape[0])
- 
 
-/////////// Atomics.proto ///////////// 
+
+/////////// Atomics.proto /////////////
 //@proto_block: utility_code_proto_before_types
- 
-#include <pythread.h> 
- 
-#ifndef CYTHON_ATOMICS 
-    #define CYTHON_ATOMICS 1 
-#endif 
- 
-#define __pyx_atomic_int_type int 
-// todo: Portland pgcc, maybe OS X's OSAtomicIncrement32, 
-//       libatomic + autotools-like distutils support? Such a pain... 
-#if CYTHON_ATOMICS && __GNUC__ >= 4 && (__GNUC_MINOR__ > 1 ||           \ 
-                    (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL >= 2)) && \ 
-                    !defined(__i386__) 
-    /* gcc >= 4.1.2 */ 
-    #define __pyx_atomic_incr_aligned(value, lock) __sync_fetch_and_add(value, 1) 
-    #define __pyx_atomic_decr_aligned(value, lock) __sync_fetch_and_sub(value, 1) 
- 
-    #ifdef __PYX_DEBUG_ATOMICS 
-        #warning "Using GNU atomics" 
-    #endif 
+
+#include <pythread.h>
+
+#ifndef CYTHON_ATOMICS
+    #define CYTHON_ATOMICS 1
+#endif
+
+#define __pyx_atomic_int_type int
+// todo: Portland pgcc, maybe OS X's OSAtomicIncrement32,
+//       libatomic + autotools-like distutils support? Such a pain...
+#if CYTHON_ATOMICS && __GNUC__ >= 4 && (__GNUC_MINOR__ > 1 ||           \
+                    (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL >= 2)) && \
+                    !defined(__i386__)
+    /* gcc >= 4.1.2 */
+    #define __pyx_atomic_incr_aligned(value, lock) __sync_fetch_and_add(value, 1)
+    #define __pyx_atomic_decr_aligned(value, lock) __sync_fetch_and_sub(value, 1)
+
+    #ifdef __PYX_DEBUG_ATOMICS
+        #warning "Using GNU atomics"
+    #endif
 #elif CYTHON_ATOMICS && defined(_MSC_VER) && 0
-    /* msvc */ 
-    #include <Windows.h> 
+    /* msvc */
+    #include <Windows.h>
     #undef __pyx_atomic_int_type
-    #define __pyx_atomic_int_type LONG 
-    #define __pyx_atomic_incr_aligned(value, lock) InterlockedIncrement(value) 
-    #define __pyx_atomic_decr_aligned(value, lock) InterlockedDecrement(value) 
- 
-    #ifdef __PYX_DEBUG_ATOMICS 
+    #define __pyx_atomic_int_type LONG
+    #define __pyx_atomic_incr_aligned(value, lock) InterlockedIncrement(value)
+    #define __pyx_atomic_decr_aligned(value, lock) InterlockedDecrement(value)
+
+    #ifdef __PYX_DEBUG_ATOMICS
         #pragma message ("Using MSVC atomics")
-    #endif 
-#elif CYTHON_ATOMICS && (defined(__ICC) || defined(__INTEL_COMPILER)) && 0 
-    #define __pyx_atomic_incr_aligned(value, lock) _InterlockedIncrement(value) 
-    #define __pyx_atomic_decr_aligned(value, lock) _InterlockedDecrement(value) 
- 
-    #ifdef __PYX_DEBUG_ATOMICS 
-        #warning "Using Intel atomics" 
-    #endif 
-#else 
-    #undef CYTHON_ATOMICS 
-    #define CYTHON_ATOMICS 0 
- 
-    #ifdef __PYX_DEBUG_ATOMICS 
-        #warning "Not using atomics" 
-    #endif 
-#endif 
- 
-typedef volatile __pyx_atomic_int_type __pyx_atomic_int; 
- 
-#if CYTHON_ATOMICS 
-    #define __pyx_add_acquisition_count(memview) \ 
-             __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock) 
-    #define __pyx_sub_acquisition_count(memview) \ 
-            __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock) 
-#else 
-    #define __pyx_add_acquisition_count(memview) \ 
-            __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) 
-    #define __pyx_sub_acquisition_count(memview) \ 
-            __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) 
-#endif 
- 
- 
-/////////////// ObjectToMemviewSlice.proto /////////////// 
- 
+    #endif
+#elif CYTHON_ATOMICS && (defined(__ICC) || defined(__INTEL_COMPILER)) && 0
+    #define __pyx_atomic_incr_aligned(value, lock) _InterlockedIncrement(value)
+    #define __pyx_atomic_decr_aligned(value, lock) _InterlockedDecrement(value)
+
+    #ifdef __PYX_DEBUG_ATOMICS
+        #warning "Using Intel atomics"
+    #endif
+#else
+    #undef CYTHON_ATOMICS
+    #define CYTHON_ATOMICS 0
+
+    #ifdef __PYX_DEBUG_ATOMICS
+        #warning "Not using atomics"
+    #endif
+#endif
+
+typedef volatile __pyx_atomic_int_type __pyx_atomic_int;
+
+#if CYTHON_ATOMICS
+    #define __pyx_add_acquisition_count(memview) \
+             __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock)
+    #define __pyx_sub_acquisition_count(memview) \
+            __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock)
+#else
+    #define __pyx_add_acquisition_count(memview) \
+            __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
+    #define __pyx_sub_acquisition_count(memview) \
+            __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
+#endif
+
+
+/////////////// ObjectToMemviewSlice.proto ///////////////
+
 static CYTHON_INLINE {{memviewslice_name}} {{funcname}}(PyObject *, int writable_flag);
- 
- 
-////////// MemviewSliceInit.proto ////////// 
- 
-#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d 
- 
-#define __Pyx_MEMVIEW_DIRECT   1 
-#define __Pyx_MEMVIEW_PTR      2 
-#define __Pyx_MEMVIEW_FULL     4 
-#define __Pyx_MEMVIEW_CONTIG   8 
-#define __Pyx_MEMVIEW_STRIDED  16 
-#define __Pyx_MEMVIEW_FOLLOW   32 
- 
-#define __Pyx_IS_C_CONTIG 1 
-#define __Pyx_IS_F_CONTIG 2 
- 
-static int __Pyx_init_memviewslice( 
-                struct __pyx_memoryview_obj *memview, 
-                int ndim, 
-                __Pyx_memviewslice *memviewslice, 
-                int memview_is_new_reference); 
- 
-static CYTHON_INLINE int __pyx_add_acquisition_count_locked( 
-    __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); 
-static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( 
-    __pyx_atomic_int *acquisition_count, PyThread_type_lock lock); 
- 
-#define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p) 
-#define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview)) 
-#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) 
-#define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__) 
-static CYTHON_INLINE void __Pyx_INC_MEMVIEW({{memviewslice_name}} *, int, int); 
-static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW({{memviewslice_name}} *, int, int); 
- 
- 
-/////////////// MemviewSliceIndex.proto /////////////// 
- 
-static CYTHON_INLINE char *__pyx_memviewslice_index_full( 
-    const char *bufp, Py_ssize_t idx, Py_ssize_t stride, Py_ssize_t suboffset); 
- 
- 
-/////////////// ObjectToMemviewSlice /////////////// 
-//@requires: MemviewSliceValidateAndInit 
- 
+
+
+////////// MemviewSliceInit.proto //////////
+
+#define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d
+
+#define __Pyx_MEMVIEW_DIRECT   1
+#define __Pyx_MEMVIEW_PTR      2
+#define __Pyx_MEMVIEW_FULL     4
+#define __Pyx_MEMVIEW_CONTIG   8
+#define __Pyx_MEMVIEW_STRIDED  16
+#define __Pyx_MEMVIEW_FOLLOW   32
+
+#define __Pyx_IS_C_CONTIG 1
+#define __Pyx_IS_F_CONTIG 2
+
+static int __Pyx_init_memviewslice(
+                struct __pyx_memoryview_obj *memview,
+                int ndim,
+                __Pyx_memviewslice *memviewslice,
+                int memview_is_new_reference);
+
+static CYTHON_INLINE int __pyx_add_acquisition_count_locked(
+    __pyx_atomic_int *acquisition_count, PyThread_type_lock lock);
+static CYTHON_INLINE int __pyx_sub_acquisition_count_locked(
+    __pyx_atomic_int *acquisition_count, PyThread_type_lock lock);
+
+#define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p)
+#define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview))
+#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__)
+#define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__)
+static CYTHON_INLINE void __Pyx_INC_MEMVIEW({{memviewslice_name}} *, int, int);
+static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW({{memviewslice_name}} *, int, int);
+
+
+/////////////// MemviewSliceIndex.proto ///////////////
+
+static CYTHON_INLINE char *__pyx_memviewslice_index_full(
+    const char *bufp, Py_ssize_t idx, Py_ssize_t stride, Py_ssize_t suboffset);
+
+
+/////////////// ObjectToMemviewSlice ///////////////
+//@requires: MemviewSliceValidateAndInit
+
 static CYTHON_INLINE {{memviewslice_name}} {{funcname}}(PyObject *obj, int writable_flag) {
-    {{memviewslice_name}} result = {{memslice_init}}; 
-    __Pyx_BufFmt_StackElem stack[{{struct_nesting_depth}}]; 
-    int axes_specs[] = { {{axes_specs}} }; 
-    int retcode; 
- 
-    if (obj == Py_None) { 
-        /* We don't bother to refcount None */ 
-        result.memview = (struct __pyx_memoryview_obj *) Py_None; 
-        return result; 
-    } 
- 
-    retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, {{c_or_f_flag}}, 
+    {{memviewslice_name}} result = {{memslice_init}};
+    __Pyx_BufFmt_StackElem stack[{{struct_nesting_depth}}];
+    int axes_specs[] = { {{axes_specs}} };
+    int retcode;
+
+    if (obj == Py_None) {
+        /* We don't bother to refcount None */
+        result.memview = (struct __pyx_memoryview_obj *) Py_None;
+        return result;
+    }
+
+    retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, {{c_or_f_flag}},
                                                  {{buf_flag}} | writable_flag, {{ndim}},
-                                                 &{{dtype_typeinfo}}, stack, 
-                                                 &result, obj); 
- 
-    if (unlikely(retcode == -1)) 
-        goto __pyx_fail; 
- 
-    return result; 
-__pyx_fail: 
-    result.memview = NULL; 
-    result.data = NULL; 
-    return result; 
-} 
- 
- 
-/////////////// MemviewSliceValidateAndInit.proto /////////////// 
- 
-static int __Pyx_ValidateAndInit_memviewslice( 
-                int *axes_specs, 
-                int c_or_f_flag, 
-                int buf_flags, 
-                int ndim, 
-                __Pyx_TypeInfo *dtype, 
-                __Pyx_BufFmt_StackElem stack[], 
-                __Pyx_memviewslice *memviewslice, 
-                PyObject *original_obj); 
- 
-/////////////// MemviewSliceValidateAndInit /////////////// 
-//@requires: Buffer.c::TypeInfoCompare 
+                                                 &{{dtype_typeinfo}}, stack,
+                                                 &result, obj);
+
+    if (unlikely(retcode == -1))
+        goto __pyx_fail;
+
+    return result;
+__pyx_fail:
+    result.memview = NULL;
+    result.data = NULL;
+    return result;
+}
+
+
+/////////////// MemviewSliceValidateAndInit.proto ///////////////
+
+static int __Pyx_ValidateAndInit_memviewslice(
+                int *axes_specs,
+                int c_or_f_flag,
+                int buf_flags,
+                int ndim,
+                __Pyx_TypeInfo *dtype,
+                __Pyx_BufFmt_StackElem stack[],
+                __Pyx_memviewslice *memviewslice,
+                PyObject *original_obj);
+
+/////////////// MemviewSliceValidateAndInit ///////////////
+//@requires: Buffer.c::TypeInfoCompare
 //@requires: Buffer.c::BufferFormatStructs
 //@requires: Buffer.c::BufferFormatCheck
- 
-static int 
-__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) 
-{ 
-    if (buf->shape[dim] <= 1) 
-        return 1; 
- 
-    if (buf->strides) { 
-        if (spec & __Pyx_MEMVIEW_CONTIG) { 
-            if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { 
+
+static int
+__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec)
+{
+    if (buf->shape[dim] <= 1)
+        return 1;
+
+    if (buf->strides) {
+        if (spec & __Pyx_MEMVIEW_CONTIG) {
+            if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) {
                 if (unlikely(buf->strides[dim] != sizeof(void *))) {
-                    PyErr_Format(PyExc_ValueError, 
-                                 "Buffer is not indirectly contiguous " 
-                                 "in dimension %d.", dim); 
-                    goto fail; 
-                } 
+                    PyErr_Format(PyExc_ValueError,
+                                 "Buffer is not indirectly contiguous "
+                                 "in dimension %d.", dim);
+                    goto fail;
+                }
             } else if (unlikely(buf->strides[dim] != buf->itemsize)) {
-                PyErr_SetString(PyExc_ValueError, 
-                                "Buffer and memoryview are not contiguous " 
-                                "in the same dimension."); 
-                goto fail; 
-            } 
-        } 
- 
-        if (spec & __Pyx_MEMVIEW_FOLLOW) { 
-            Py_ssize_t stride = buf->strides[dim]; 
-            if (stride < 0) 
-                stride = -stride; 
+                PyErr_SetString(PyExc_ValueError,
+                                "Buffer and memoryview are not contiguous "
+                                "in the same dimension.");
+                goto fail;
+            }
+        }
+
+        if (spec & __Pyx_MEMVIEW_FOLLOW) {
+            Py_ssize_t stride = buf->strides[dim];
+            if (stride < 0)
+                stride = -stride;
             if (unlikely(stride < buf->itemsize)) {
-                PyErr_SetString(PyExc_ValueError, 
-                                "Buffer and memoryview are not contiguous " 
-                                "in the same dimension."); 
-                goto fail; 
-            } 
-        } 
-    } else { 
+                PyErr_SetString(PyExc_ValueError,
+                                "Buffer and memoryview are not contiguous "
+                                "in the same dimension.");
+                goto fail;
+            }
+        }
+    } else {
         if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) {
-            PyErr_Format(PyExc_ValueError, 
-                         "C-contiguous buffer is not contiguous in " 
-                         "dimension %d", dim); 
-            goto fail; 
+            PyErr_Format(PyExc_ValueError,
+                         "C-contiguous buffer is not contiguous in "
+                         "dimension %d", dim);
+            goto fail;
         } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) {
-            PyErr_Format(PyExc_ValueError, 
-                         "C-contiguous buffer is not indirect in " 
-                         "dimension %d", dim); 
-            goto fail; 
+            PyErr_Format(PyExc_ValueError,
+                         "C-contiguous buffer is not indirect in "
+                         "dimension %d", dim);
+            goto fail;
         } else if (unlikely(buf->suboffsets)) {
-            PyErr_SetString(PyExc_ValueError, 
-                            "Buffer exposes suboffsets but no strides"); 
-            goto fail; 
-        } 
-    } 
- 
-    return 1; 
-fail: 
-    return 0; 
-} 
- 
-static int 
-__pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec) 
-{ 
-    // Todo: without PyBUF_INDIRECT we may not have suboffset information, i.e., the 
-    //       ptr may not be set to NULL but may be uninitialized? 
-    if (spec & __Pyx_MEMVIEW_DIRECT) { 
+            PyErr_SetString(PyExc_ValueError,
+                            "Buffer exposes suboffsets but no strides");
+            goto fail;
+        }
+    }
+
+    return 1;
+fail:
+    return 0;
+}
+
+static int
+__pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec)
+{
+    // Todo: without PyBUF_INDIRECT we may not have suboffset information, i.e., the
+    //       ptr may not be set to NULL but may be uninitialized?
+    if (spec & __Pyx_MEMVIEW_DIRECT) {
         if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) {
-            PyErr_Format(PyExc_ValueError, 
-                         "Buffer not compatible with direct access " 
-                         "in dimension %d.", dim); 
-            goto fail; 
-        } 
-    } 
- 
-    if (spec & __Pyx_MEMVIEW_PTR) { 
+            PyErr_Format(PyExc_ValueError,
+                         "Buffer not compatible with direct access "
+                         "in dimension %d.", dim);
+            goto fail;
+        }
+    }
+
+    if (spec & __Pyx_MEMVIEW_PTR) {
         if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) {
-            PyErr_Format(PyExc_ValueError, 
-                         "Buffer is not indirectly accessible " 
-                         "in dimension %d.", dim); 
-            goto fail; 
-        } 
-    } 
- 
-    return 1; 
-fail: 
-    return 0; 
-} 
- 
-static int 
-__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) 
-{ 
-    int i; 
- 
-    if (c_or_f_flag & __Pyx_IS_F_CONTIG) { 
-        Py_ssize_t stride = 1; 
-        for (i = 0; i < ndim; i++) { 
+            PyErr_Format(PyExc_ValueError,
+                         "Buffer is not indirectly accessible "
+                         "in dimension %d.", dim);
+            goto fail;
+        }
+    }
+
+    return 1;
+fail:
+    return 0;
+}
+
+static int
+__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag)
+{
+    int i;
+
+    if (c_or_f_flag & __Pyx_IS_F_CONTIG) {
+        Py_ssize_t stride = 1;
+        for (i = 0; i < ndim; i++) {
             if (unlikely(stride * buf->itemsize != buf->strides[i]  &&  buf->shape[i] > 1)) {
-                PyErr_SetString(PyExc_ValueError, 
-                    "Buffer not fortran contiguous."); 
-                goto fail; 
-            } 
-            stride = stride * buf->shape[i]; 
-        } 
-    } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) { 
-        Py_ssize_t stride = 1; 
-        for (i = ndim - 1; i >- 1; i--) { 
+                PyErr_SetString(PyExc_ValueError,
+                    "Buffer not fortran contiguous.");
+                goto fail;
+            }
+            stride = stride * buf->shape[i];
+        }
+    } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) {
+        Py_ssize_t stride = 1;
+        for (i = ndim - 1; i >- 1; i--) {
             if (unlikely(stride * buf->itemsize != buf->strides[i]  &&  buf->shape[i] > 1)) {
-                PyErr_SetString(PyExc_ValueError, 
-                    "Buffer not C contiguous."); 
-                goto fail; 
-            } 
-            stride = stride * buf->shape[i]; 
-        } 
-    } 
- 
-    return 1; 
-fail: 
-    return 0; 
-} 
- 
-static int __Pyx_ValidateAndInit_memviewslice( 
-                int *axes_specs, 
-                int c_or_f_flag, 
-                int buf_flags, 
-                int ndim, 
-                __Pyx_TypeInfo *dtype, 
-                __Pyx_BufFmt_StackElem stack[], 
-                __Pyx_memviewslice *memviewslice, 
-                PyObject *original_obj) 
-{ 
-    struct __pyx_memoryview_obj *memview, *new_memview; 
-    __Pyx_RefNannyDeclarations 
-    Py_buffer *buf; 
-    int i, spec = 0, retval = -1; 
-    __Pyx_BufFmt_Context ctx; 
-    int from_memoryview = __pyx_memoryview_check(original_obj); 
- 
-    __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); 
- 
-    if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) 
-                                                            original_obj)->typeinfo)) { 
-        /* We have a matching dtype, skip format parsing */ 
-        memview = (struct __pyx_memoryview_obj *) original_obj; 
-        new_memview = NULL; 
-    } else { 
-        memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( 
-                                            original_obj, buf_flags, 0, dtype); 
-        new_memview = memview; 
-        if (unlikely(!memview)) 
-            goto fail; 
-    } 
- 
-    buf = &memview->view; 
+                PyErr_SetString(PyExc_ValueError,
+                    "Buffer not C contiguous.");
+                goto fail;
+            }
+            stride = stride * buf->shape[i];
+        }
+    }
+
+    return 1;
+fail:
+    return 0;
+}
+
+static int __Pyx_ValidateAndInit_memviewslice(
+                int *axes_specs,
+                int c_or_f_flag,
+                int buf_flags,
+                int ndim,
+                __Pyx_TypeInfo *dtype,
+                __Pyx_BufFmt_StackElem stack[],
+                __Pyx_memviewslice *memviewslice,
+                PyObject *original_obj)
+{
+    struct __pyx_memoryview_obj *memview, *new_memview;
+    __Pyx_RefNannyDeclarations
+    Py_buffer *buf;
+    int i, spec = 0, retval = -1;
+    __Pyx_BufFmt_Context ctx;
+    int from_memoryview = __pyx_memoryview_check(original_obj);
+
+    __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0);
+
+    if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *)
+                                                            original_obj)->typeinfo)) {
+        /* We have a matching dtype, skip format parsing */
+        memview = (struct __pyx_memoryview_obj *) original_obj;
+        new_memview = NULL;
+    } else {
+        memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new(
+                                            original_obj, buf_flags, 0, dtype);
+        new_memview = memview;
+        if (unlikely(!memview))
+            goto fail;
+    }
+
+    buf = &memview->view;
     if (unlikely(buf->ndim != ndim)) {
-        PyErr_Format(PyExc_ValueError, 
-                "Buffer has wrong number of dimensions (expected %d, got %d)", 
-                ndim, buf->ndim); 
-        goto fail; 
-    } 
- 
-    if (new_memview) { 
-        __Pyx_BufFmt_Init(&ctx, stack, dtype); 
+        PyErr_Format(PyExc_ValueError,
+                "Buffer has wrong number of dimensions (expected %d, got %d)",
+                ndim, buf->ndim);
+        goto fail;
+    }
+
+    if (new_memview) {
+        __Pyx_BufFmt_Init(&ctx, stack, dtype);
         if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail;
-    } 
- 
+    }
+
     if (unlikely((unsigned) buf->itemsize != dtype->size)) {
-        PyErr_Format(PyExc_ValueError, 
-                     "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " 
-                     "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", 
-                     buf->itemsize, 
-                     (buf->itemsize > 1) ? "s" : "", 
-                     dtype->name, 
-                     dtype->size, 
-                     (dtype->size > 1) ? "s" : ""); 
-        goto fail; 
-    } 
- 
-    /* Check axes */ 
+        PyErr_Format(PyExc_ValueError,
+                     "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) "
+                     "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)",
+                     buf->itemsize,
+                     (buf->itemsize > 1) ? "s" : "",
+                     dtype->name,
+                     dtype->size,
+                     (dtype->size > 1) ? "s" : "");
+        goto fail;
+    }
+
+    /* Check axes */
     if (buf->len > 0) {
         // 0-sized arrays do not undergo these checks since their strides are
         // irrelevant and they are always both C- and F-contiguous.
@@ -360,506 +360,506 @@ static int __Pyx_ValidateAndInit_memviewslice(
 
         /* Check contiguity */
         if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag)))
-            goto fail; 
-    } 
- 
-    /* Initialize */ 
-    if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, 
-                                         new_memview != NULL) == -1)) { 
-        goto fail; 
-    } 
- 
-    retval = 0; 
-    goto no_fail; 
- 
-fail: 
-    Py_XDECREF(new_memview); 
-    retval = -1; 
- 
-no_fail: 
-    __Pyx_RefNannyFinishContext(); 
-    return retval; 
-} 
- 
- 
-////////// MemviewSliceInit ////////// 
- 
-static int 
-__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, 
-                        int ndim, 
-                        {{memviewslice_name}} *memviewslice, 
-                        int memview_is_new_reference) 
-{ 
-    __Pyx_RefNannyDeclarations 
-    int i, retval=-1; 
-    Py_buffer *buf = &memview->view; 
-    __Pyx_RefNannySetupContext("init_memviewslice", 0); 
- 
+            goto fail;
+    }
+
+    /* Initialize */
+    if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice,
+                                         new_memview != NULL) == -1)) {
+        goto fail;
+    }
+
+    retval = 0;
+    goto no_fail;
+
+fail:
+    Py_XDECREF(new_memview);
+    retval = -1;
+
+no_fail:
+    __Pyx_RefNannyFinishContext();
+    return retval;
+}
+
+
+////////// MemviewSliceInit //////////
+
+static int
+__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview,
+                        int ndim,
+                        {{memviewslice_name}} *memviewslice,
+                        int memview_is_new_reference)
+{
+    __Pyx_RefNannyDeclarations
+    int i, retval=-1;
+    Py_buffer *buf = &memview->view;
+    __Pyx_RefNannySetupContext("init_memviewslice", 0);
+
     if (unlikely(memviewslice->memview || memviewslice->data)) {
-        PyErr_SetString(PyExc_ValueError, 
-            "memviewslice is already initialized!"); 
-        goto fail; 
-    } 
- 
-    if (buf->strides) { 
-        for (i = 0; i < ndim; i++) { 
-            memviewslice->strides[i] = buf->strides[i]; 
-        } 
-    } else { 
-        Py_ssize_t stride = buf->itemsize; 
-        for (i = ndim - 1; i >= 0; i--) { 
-            memviewslice->strides[i] = stride; 
-            stride *= buf->shape[i]; 
-        } 
-    } 
- 
-    for (i = 0; i < ndim; i++) { 
-        memviewslice->shape[i]   = buf->shape[i]; 
-        if (buf->suboffsets) { 
-            memviewslice->suboffsets[i] = buf->suboffsets[i]; 
-        } else { 
-            memviewslice->suboffsets[i] = -1; 
-        } 
-    } 
- 
-    memviewslice->memview = memview; 
-    memviewslice->data = (char *)buf->buf; 
-    if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { 
-        Py_INCREF(memview); 
-    } 
-    retval = 0; 
-    goto no_fail; 
- 
-fail: 
-    /* Don't decref, the memoryview may be borrowed. Let the caller do the cleanup */ 
-    /* __Pyx_XDECREF(memviewslice->memview); */ 
-    memviewslice->memview = 0; 
-    memviewslice->data = 0; 
-    retval = -1; 
-no_fail: 
-    __Pyx_RefNannyFinishContext(); 
-    return retval; 
-} 
- 
+        PyErr_SetString(PyExc_ValueError,
+            "memviewslice is already initialized!");
+        goto fail;
+    }
+
+    if (buf->strides) {
+        for (i = 0; i < ndim; i++) {
+            memviewslice->strides[i] = buf->strides[i];
+        }
+    } else {
+        Py_ssize_t stride = buf->itemsize;
+        for (i = ndim - 1; i >= 0; i--) {
+            memviewslice->strides[i] = stride;
+            stride *= buf->shape[i];
+        }
+    }
+
+    for (i = 0; i < ndim; i++) {
+        memviewslice->shape[i]   = buf->shape[i];
+        if (buf->suboffsets) {
+            memviewslice->suboffsets[i] = buf->suboffsets[i];
+        } else {
+            memviewslice->suboffsets[i] = -1;
+        }
+    }
+
+    memviewslice->memview = memview;
+    memviewslice->data = (char *)buf->buf;
+    if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) {
+        Py_INCREF(memview);
+    }
+    retval = 0;
+    goto no_fail;
+
+fail:
+    /* Don't decref, the memoryview may be borrowed. Let the caller do the cleanup */
+    /* __Pyx_XDECREF(memviewslice->memview); */
+    memviewslice->memview = 0;
+    memviewslice->data = 0;
+    retval = -1;
+no_fail:
+    __Pyx_RefNannyFinishContext();
+    return retval;
+}
+
 #ifndef Py_NO_RETURN
 // available since Py3.3
 #define Py_NO_RETURN
 #endif
- 
+
 static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN {
-    va_list vargs; 
-    char msg[200]; 
- 
-#ifdef HAVE_STDARG_PROTOTYPES 
-    va_start(vargs, fmt); 
-#else 
-    va_start(vargs); 
-#endif 
+    va_list vargs;
+    char msg[200];
+
+#ifdef HAVE_STDARG_PROTOTYPES
+    va_start(vargs, fmt);
+#else
+    va_start(vargs);
+#endif
     vsnprintf(msg, 200, fmt, vargs);
     va_end(vargs);
- 
-    Py_FatalError(msg); 
-} 
- 
-static CYTHON_INLINE int 
-__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count, 
-                                   PyThread_type_lock lock) 
-{ 
-    int result; 
-    PyThread_acquire_lock(lock, 1); 
-    result = (*acquisition_count)++; 
-    PyThread_release_lock(lock); 
-    return result; 
-} 
- 
-static CYTHON_INLINE int 
-__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count, 
-                                   PyThread_type_lock lock) 
-{ 
-    int result; 
-    PyThread_acquire_lock(lock, 1); 
-    result = (*acquisition_count)--; 
-    PyThread_release_lock(lock); 
-    return result; 
-} 
- 
- 
-static CYTHON_INLINE void 
-__Pyx_INC_MEMVIEW({{memviewslice_name}} *memslice, int have_gil, int lineno) 
-{ 
-    int first_time; 
-    struct {{memview_struct_name}} *memview = memslice->memview; 
+
+    Py_FatalError(msg);
+}
+
+static CYTHON_INLINE int
+__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count,
+                                   PyThread_type_lock lock)
+{
+    int result;
+    PyThread_acquire_lock(lock, 1);
+    result = (*acquisition_count)++;
+    PyThread_release_lock(lock);
+    return result;
+}
+
+static CYTHON_INLINE int
+__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count,
+                                   PyThread_type_lock lock)
+{
+    int result;
+    PyThread_acquire_lock(lock, 1);
+    result = (*acquisition_count)--;
+    PyThread_release_lock(lock);
+    return result;
+}
+
+
+static CYTHON_INLINE void
+__Pyx_INC_MEMVIEW({{memviewslice_name}} *memslice, int have_gil, int lineno)
+{
+    int first_time;
+    struct {{memview_struct_name}} *memview = memslice->memview;
     if (unlikely(!memview || (PyObject *) memview == Py_None))
-        return; /* allow uninitialized memoryview assignment */ 
- 
+        return; /* allow uninitialized memoryview assignment */
+
     if (unlikely(__pyx_get_slice_count(memview) < 0))
-        __pyx_fatalerror("Acquisition count is %d (line %d)", 
-                         __pyx_get_slice_count(memview), lineno); 
- 
-    first_time = __pyx_add_acquisition_count(memview) == 0; 
- 
+        __pyx_fatalerror("Acquisition count is %d (line %d)",
+                         __pyx_get_slice_count(memview), lineno);
+
+    first_time = __pyx_add_acquisition_count(memview) == 0;
+
     if (unlikely(first_time)) {
-        if (have_gil) { 
-            Py_INCREF((PyObject *) memview); 
-        } else { 
-            PyGILState_STATE _gilstate = PyGILState_Ensure(); 
-            Py_INCREF((PyObject *) memview); 
-            PyGILState_Release(_gilstate); 
-        } 
-    } 
-} 
- 
-static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW({{memviewslice_name}} *memslice, 
-                                             int have_gil, int lineno) { 
-    int last_time; 
-    struct {{memview_struct_name}} *memview = memslice->memview; 
- 
+        if (have_gil) {
+            Py_INCREF((PyObject *) memview);
+        } else {
+            PyGILState_STATE _gilstate = PyGILState_Ensure();
+            Py_INCREF((PyObject *) memview);
+            PyGILState_Release(_gilstate);
+        }
+    }
+}
+
+static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW({{memviewslice_name}} *memslice,
+                                             int have_gil, int lineno) {
+    int last_time;
+    struct {{memview_struct_name}} *memview = memslice->memview;
+
     if (unlikely(!memview || (PyObject *) memview == Py_None)) {
         // we do not ref-count None
-        memslice->memview = NULL; 
-        return; 
-    } 
- 
+        memslice->memview = NULL;
+        return;
+    }
+
     if (unlikely(__pyx_get_slice_count(memview) <= 0))
-        __pyx_fatalerror("Acquisition count is %d (line %d)", 
-                         __pyx_get_slice_count(memview), lineno); 
- 
-    last_time = __pyx_sub_acquisition_count(memview) == 1; 
-    memslice->data = NULL; 
+        __pyx_fatalerror("Acquisition count is %d (line %d)",
+                         __pyx_get_slice_count(memview), lineno);
+
+    last_time = __pyx_sub_acquisition_count(memview) == 1;
+    memslice->data = NULL;
 
     if (unlikely(last_time)) {
-        if (have_gil) { 
-            Py_CLEAR(memslice->memview); 
-        } else { 
-            PyGILState_STATE _gilstate = PyGILState_Ensure(); 
-            Py_CLEAR(memslice->memview); 
-            PyGILState_Release(_gilstate); 
-        } 
-    } else { 
-        memslice->memview = NULL; 
-    } 
-} 
- 
- 
-////////// MemviewSliceCopyTemplate.proto ////////// 
- 
-static {{memviewslice_name}} 
-__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, 
-                                 const char *mode, int ndim, 
-                                 size_t sizeof_dtype, int contig_flag, 
-                                 int dtype_is_object); 
- 
- 
-////////// MemviewSliceCopyTemplate ////////// 
- 
-static {{memviewslice_name}} 
-__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, 
-                                 const char *mode, int ndim, 
-                                 size_t sizeof_dtype, int contig_flag, 
-                                 int dtype_is_object) 
-{ 
-    __Pyx_RefNannyDeclarations 
-    int i; 
-    __Pyx_memviewslice new_mvs = {{memslice_init}}; 
-    struct __pyx_memoryview_obj *from_memview = from_mvs->memview; 
-    Py_buffer *buf = &from_memview->view; 
-    PyObject *shape_tuple = NULL; 
-    PyObject *temp_int = NULL; 
-    struct __pyx_array_obj *array_obj = NULL; 
-    struct __pyx_memoryview_obj *memview_obj = NULL; 
- 
-    __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0); 
- 
-    for (i = 0; i < ndim; i++) { 
+        if (have_gil) {
+            Py_CLEAR(memslice->memview);
+        } else {
+            PyGILState_STATE _gilstate = PyGILState_Ensure();
+            Py_CLEAR(memslice->memview);
+            PyGILState_Release(_gilstate);
+        }
+    } else {
+        memslice->memview = NULL;
+    }
+}
+
+
+////////// MemviewSliceCopyTemplate.proto //////////
+
+static {{memviewslice_name}}
+__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
+                                 const char *mode, int ndim,
+                                 size_t sizeof_dtype, int contig_flag,
+                                 int dtype_is_object);
+
+
+////////// MemviewSliceCopyTemplate //////////
+
+static {{memviewslice_name}}
+__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
+                                 const char *mode, int ndim,
+                                 size_t sizeof_dtype, int contig_flag,
+                                 int dtype_is_object)
+{
+    __Pyx_RefNannyDeclarations
+    int i;
+    __Pyx_memviewslice new_mvs = {{memslice_init}};
+    struct __pyx_memoryview_obj *from_memview = from_mvs->memview;
+    Py_buffer *buf = &from_memview->view;
+    PyObject *shape_tuple = NULL;
+    PyObject *temp_int = NULL;
+    struct __pyx_array_obj *array_obj = NULL;
+    struct __pyx_memoryview_obj *memview_obj = NULL;
+
+    __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0);
+
+    for (i = 0; i < ndim; i++) {
         if (unlikely(from_mvs->suboffsets[i] >= 0)) {
-            PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " 
-                                           "indirect dimensions (axis %d)", i); 
-            goto fail; 
-        } 
-    } 
- 
-    shape_tuple = PyTuple_New(ndim); 
-    if (unlikely(!shape_tuple)) { 
-        goto fail; 
-    } 
-    __Pyx_GOTREF(shape_tuple); 
- 
- 
-    for(i = 0; i < ndim; i++) { 
-        temp_int = PyInt_FromSsize_t(from_mvs->shape[i]); 
-        if(unlikely(!temp_int)) { 
-            goto fail; 
-        } else { 
-            PyTuple_SET_ITEM(shape_tuple, i, temp_int); 
-            temp_int = NULL; 
-        } 
-    } 
- 
-    array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL); 
-    if (unlikely(!array_obj)) { 
-        goto fail; 
-    } 
-    __Pyx_GOTREF(array_obj); 
- 
-    memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( 
-                                    (PyObject *) array_obj, contig_flag, 
-                                    dtype_is_object, 
-                                    from_mvs->memview->typeinfo); 
-    if (unlikely(!memview_obj)) 
-        goto fail; 
- 
-    /* initialize new_mvs */ 
-    if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) 
-        goto fail; 
- 
-    if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, 
-                                                dtype_is_object) < 0)) 
-        goto fail; 
- 
-    goto no_fail; 
- 
-fail: 
-    __Pyx_XDECREF(new_mvs.memview); 
-    new_mvs.memview = NULL; 
-    new_mvs.data = NULL; 
-no_fail: 
-    __Pyx_XDECREF(shape_tuple); 
-    __Pyx_XDECREF(temp_int); 
-    __Pyx_XDECREF(array_obj); 
-    __Pyx_RefNannyFinishContext(); 
-    return new_mvs; 
-} 
- 
- 
-////////// CopyContentsUtility.proto ///////// 
- 
-#define {{func_cname}}(slice) \ 
-        __pyx_memoryview_copy_new_contig(&slice, "{{mode}}", {{ndim}},            \ 
-                                         sizeof({{dtype_decl}}), {{contig_flag}}, \ 
-                                         {{dtype_is_object}}) 
- 
- 
-////////// OverlappingSlices.proto ////////// 
- 
-static int __pyx_slices_overlap({{memviewslice_name}} *slice1, 
-                                {{memviewslice_name}} *slice2, 
-                                int ndim, size_t itemsize); 
- 
- 
-////////// OverlappingSlices ////////// 
- 
-/* Based on numpy's core/src/multiarray/array_assign.c */ 
- 
-/* Gets a half-open range [start, end) which contains the array data */ 
-static void 
-__pyx_get_array_memory_extents({{memviewslice_name}} *slice, 
-                               void **out_start, void **out_end, 
-                               int ndim, size_t itemsize) 
-{ 
-    char *start, *end; 
-    int i; 
- 
-    start = end = slice->data; 
- 
-    for (i = 0; i < ndim; i++) { 
-        Py_ssize_t stride = slice->strides[i]; 
-        Py_ssize_t extent = slice->shape[i]; 
- 
-        if (extent == 0) { 
-            *out_start = *out_end = start; 
-            return; 
-        } else { 
-            if (stride > 0) 
-                end += stride * (extent - 1); 
-            else 
-                start += stride * (extent - 1); 
-        } 
-    } 
- 
-    /* Return a half-open range */ 
-    *out_start = start; 
-    *out_end = end + itemsize; 
-} 
- 
-/* Returns 1 if the arrays have overlapping data, 0 otherwise */ 
-static int 
-__pyx_slices_overlap({{memviewslice_name}} *slice1, 
-                     {{memviewslice_name}} *slice2, 
-                     int ndim, size_t itemsize) 
-{ 
-    void *start1, *end1, *start2, *end2; 
- 
-    __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); 
-    __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); 
- 
-    return (start1 < end2) && (start2 < end1); 
-} 
- 
- 
+            PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with "
+                                           "indirect dimensions (axis %d)", i);
+            goto fail;
+        }
+    }
+
+    shape_tuple = PyTuple_New(ndim);
+    if (unlikely(!shape_tuple)) {
+        goto fail;
+    }
+    __Pyx_GOTREF(shape_tuple);
+
+
+    for(i = 0; i < ndim; i++) {
+        temp_int = PyInt_FromSsize_t(from_mvs->shape[i]);
+        if(unlikely(!temp_int)) {
+            goto fail;
+        } else {
+            PyTuple_SET_ITEM(shape_tuple, i, temp_int);
+            temp_int = NULL;
+        }
+    }
+
+    array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL);
+    if (unlikely(!array_obj)) {
+        goto fail;
+    }
+    __Pyx_GOTREF(array_obj);
+
+    memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new(
+                                    (PyObject *) array_obj, contig_flag,
+                                    dtype_is_object,
+                                    from_mvs->memview->typeinfo);
+    if (unlikely(!memview_obj))
+        goto fail;
+
+    /* initialize new_mvs */
+    if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0))
+        goto fail;
+
+    if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim,
+                                                dtype_is_object) < 0))
+        goto fail;
+
+    goto no_fail;
+
+fail:
+    __Pyx_XDECREF(new_mvs.memview);
+    new_mvs.memview = NULL;
+    new_mvs.data = NULL;
+no_fail:
+    __Pyx_XDECREF(shape_tuple);
+    __Pyx_XDECREF(temp_int);
+    __Pyx_XDECREF(array_obj);
+    __Pyx_RefNannyFinishContext();
+    return new_mvs;
+}
+
+
+////////// CopyContentsUtility.proto /////////
+
+#define {{func_cname}}(slice) \
+        __pyx_memoryview_copy_new_contig(&slice, "{{mode}}", {{ndim}},            \
+                                         sizeof({{dtype_decl}}), {{contig_flag}}, \
+                                         {{dtype_is_object}})
+
+
+////////// OverlappingSlices.proto //////////
+
+static int __pyx_slices_overlap({{memviewslice_name}} *slice1,
+                                {{memviewslice_name}} *slice2,
+                                int ndim, size_t itemsize);
+
+
+////////// OverlappingSlices //////////
+
+/* Based on numpy's core/src/multiarray/array_assign.c */
+
+/* Gets a half-open range [start, end) which contains the array data */
+static void
+__pyx_get_array_memory_extents({{memviewslice_name}} *slice,
+                               void **out_start, void **out_end,
+                               int ndim, size_t itemsize)
+{
+    char *start, *end;
+    int i;
+
+    start = end = slice->data;
+
+    for (i = 0; i < ndim; i++) {
+        Py_ssize_t stride = slice->strides[i];
+        Py_ssize_t extent = slice->shape[i];
+
+        if (extent == 0) {
+            *out_start = *out_end = start;
+            return;
+        } else {
+            if (stride > 0)
+                end += stride * (extent - 1);
+            else
+                start += stride * (extent - 1);
+        }
+    }
+
+    /* Return a half-open range */
+    *out_start = start;
+    *out_end = end + itemsize;
+}
+
+/* Returns 1 if the arrays have overlapping data, 0 otherwise */
+static int
+__pyx_slices_overlap({{memviewslice_name}} *slice1,
+                     {{memviewslice_name}} *slice2,
+                     int ndim, size_t itemsize)
+{
+    void *start1, *end1, *start2, *end2;
+
+    __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize);
+    __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize);
+
+    return (start1 < end2) && (start2 < end1);
+}
+
+
 ////////// MemviewSliceCheckContig.proto //////////
- 
+
 #define __pyx_memviewslice_is_contig_{{contig_type}}{{ndim}}(slice) \
     __pyx_memviewslice_is_contig(slice, '{{contig_type}}', {{ndim}})
- 
- 
-////////// MemviewSliceIsContig.proto ////////// 
- 
+
+
+////////// MemviewSliceIsContig.proto //////////
+
 static int __pyx_memviewslice_is_contig(const {{memviewslice_name}} mvs, char order, int ndim);/*proto*/
- 
- 
-////////// MemviewSliceIsContig ////////// 
- 
-static int 
+
+
+////////// MemviewSliceIsContig //////////
+
+static int
 __pyx_memviewslice_is_contig(const {{memviewslice_name}} mvs, char order, int ndim)
-{ 
-    int i, index, step, start; 
+{
+    int i, index, step, start;
     Py_ssize_t itemsize = mvs.memview->view.itemsize;
- 
-    if (order == 'F') { 
-        step = 1; 
-        start = 0; 
-    } else { 
-        step = -1; 
-        start = ndim - 1; 
-    } 
- 
-    for (i = 0; i < ndim; i++) { 
-        index = start + step * i; 
+
+    if (order == 'F') {
+        step = 1;
+        start = 0;
+    } else {
+        step = -1;
+        start = ndim - 1;
+    }
+
+    for (i = 0; i < ndim; i++) {
+        index = start + step * i;
         if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize)
-            return 0; 
- 
+            return 0;
+
         itemsize *= mvs.shape[index];
-    } 
- 
-    return 1; 
-} 
- 
- 
-/////////////// MemviewSliceIndex /////////////// 
- 
-static CYTHON_INLINE char * 
-__pyx_memviewslice_index_full(const char *bufp, Py_ssize_t idx, 
-                              Py_ssize_t stride, Py_ssize_t suboffset) 
-{ 
-    bufp = bufp + idx * stride; 
-    if (suboffset >= 0) { 
-        bufp = *((char **) bufp) + suboffset; 
-    } 
-    return (char *) bufp; 
-} 
- 
- 
-/////////////// MemviewDtypeToObject.proto /////////////// 
- 
-{{if to_py_function}} 
+    }
+
+    return 1;
+}
+
+
+/////////////// MemviewSliceIndex ///////////////
+
+static CYTHON_INLINE char *
+__pyx_memviewslice_index_full(const char *bufp, Py_ssize_t idx,
+                              Py_ssize_t stride, Py_ssize_t suboffset)
+{
+    bufp = bufp + idx * stride;
+    if (suboffset >= 0) {
+        bufp = *((char **) bufp) + suboffset;
+    }
+    return (char *) bufp;
+}
+
+
+/////////////// MemviewDtypeToObject.proto ///////////////
+
+{{if to_py_function}}
 static CYTHON_INLINE PyObject *{{get_function}}(const char *itemp); /* proto */
-{{endif}} 
- 
-{{if from_py_function}} 
+{{endif}}
+
+{{if from_py_function}}
 static CYTHON_INLINE int {{set_function}}(const char *itemp, PyObject *obj); /* proto */
-{{endif}} 
- 
-/////////////// MemviewDtypeToObject /////////////// 
- 
-{{#__pyx_memview_<dtype_name>_to_object}} 
- 
-/* Convert a dtype to or from a Python object */ 
- 
-{{if to_py_function}} 
+{{endif}}
+
+/////////////// MemviewDtypeToObject ///////////////
+
+{{#__pyx_memview_<dtype_name>_to_object}}
+
+/* Convert a dtype to or from a Python object */
+
+{{if to_py_function}}
 static CYTHON_INLINE PyObject *{{get_function}}(const char *itemp) {
-    return (PyObject *) {{to_py_function}}(*({{dtype}} *) itemp); 
-} 
-{{endif}} 
- 
-{{if from_py_function}} 
+    return (PyObject *) {{to_py_function}}(*({{dtype}} *) itemp);
+}
+{{endif}}
+
+{{if from_py_function}}
 static CYTHON_INLINE int {{set_function}}(const char *itemp, PyObject *obj) {
-    {{dtype}} value = {{from_py_function}}(obj); 
-    if ({{error_condition}}) 
-        return 0; 
-    *({{dtype}} *) itemp = value; 
-    return 1; 
-} 
-{{endif}} 
- 
- 
-/////////////// MemviewObjectToObject.proto /////////////// 
- 
-/* Function callbacks (for memoryview object) for dtype object */ 
-static PyObject *{{get_function}}(const char *itemp); /* proto */ 
-static int {{set_function}}(const char *itemp, PyObject *obj); /* proto */ 
- 
- 
-/////////////// MemviewObjectToObject /////////////// 
- 
-static PyObject *{{get_function}}(const char *itemp) { 
-    PyObject *result = *(PyObject **) itemp; 
-    Py_INCREF(result); 
-    return result; 
-} 
- 
-static int {{set_function}}(const char *itemp, PyObject *obj) { 
-    Py_INCREF(obj); 
-    Py_DECREF(*(PyObject **) itemp); 
-    *(PyObject **) itemp = obj; 
-    return 1; 
-} 
- 
-/////////// ToughSlice ////////// 
- 
-/* Dimension is indexed with 'start:stop:step' */ 
- 
-if (unlikely(__pyx_memoryview_slice_memviewslice( 
-    &{{dst}}, 
-    {{src}}.shape[{{dim}}], {{src}}.strides[{{dim}}], {{src}}.suboffsets[{{dim}}], 
-    {{dim}}, 
-    {{new_ndim}}, 
+    {{dtype}} value = {{from_py_function}}(obj);
+    if ({{error_condition}})
+        return 0;
+    *({{dtype}} *) itemp = value;
+    return 1;
+}
+{{endif}}
+
+
+/////////////// MemviewObjectToObject.proto ///////////////
+
+/* Function callbacks (for memoryview object) for dtype object */
+static PyObject *{{get_function}}(const char *itemp); /* proto */
+static int {{set_function}}(const char *itemp, PyObject *obj); /* proto */
+
+
+/////////////// MemviewObjectToObject ///////////////
+
+static PyObject *{{get_function}}(const char *itemp) {
+    PyObject *result = *(PyObject **) itemp;
+    Py_INCREF(result);
+    return result;
+}
+
+static int {{set_function}}(const char *itemp, PyObject *obj) {
+    Py_INCREF(obj);
+    Py_DECREF(*(PyObject **) itemp);
+    *(PyObject **) itemp = obj;
+    return 1;
+}
+
+/////////// ToughSlice //////////
+
+/* Dimension is indexed with 'start:stop:step' */
+
+if (unlikely(__pyx_memoryview_slice_memviewslice(
+    &{{dst}},
+    {{src}}.shape[{{dim}}], {{src}}.strides[{{dim}}], {{src}}.suboffsets[{{dim}}],
+    {{dim}},
+    {{new_ndim}},
     &{{get_suboffset_dim()}},
-    {{start}}, 
-    {{stop}}, 
-    {{step}}, 
-    {{int(have_start)}}, 
-    {{int(have_stop)}}, 
-    {{int(have_step)}}, 
-    1) < 0)) 
-{ 
-    {{error_goto}} 
-} 
- 
- 
-////////// SimpleSlice ////////// 
- 
-/* Dimension is indexed with ':' only */ 
- 
-{{dst}}.shape[{{new_ndim}}] = {{src}}.shape[{{dim}}]; 
-{{dst}}.strides[{{new_ndim}}] = {{src}}.strides[{{dim}}]; 
- 
-{{if access == 'direct'}} 
-    {{dst}}.suboffsets[{{new_ndim}}] = -1; 
-{{else}} 
-    {{dst}}.suboffsets[{{new_ndim}}] = {{src}}.suboffsets[{{dim}}]; 
-    if ({{src}}.suboffsets[{{dim}}] >= 0) 
+    {{start}},
+    {{stop}},
+    {{step}},
+    {{int(have_start)}},
+    {{int(have_stop)}},
+    {{int(have_step)}},
+    1) < 0))
+{
+    {{error_goto}}
+}
+
+
+////////// SimpleSlice //////////
+
+/* Dimension is indexed with ':' only */
+
+{{dst}}.shape[{{new_ndim}}] = {{src}}.shape[{{dim}}];
+{{dst}}.strides[{{new_ndim}}] = {{src}}.strides[{{dim}}];
+
+{{if access == 'direct'}}
+    {{dst}}.suboffsets[{{new_ndim}}] = -1;
+{{else}}
+    {{dst}}.suboffsets[{{new_ndim}}] = {{src}}.suboffsets[{{dim}}];
+    if ({{src}}.suboffsets[{{dim}}] >= 0)
         {{get_suboffset_dim()}} = {{new_ndim}};
-{{endif}} 
- 
- 
-////////// SliceIndex ////////// 
- 
-// Dimension is indexed with an integer, we could use the ToughSlice 
-// approach, but this is faster 
- 
-{ 
-    Py_ssize_t __pyx_tmp_idx = {{idx}}; 
+{{endif}}
+
+
+////////// SliceIndex //////////
+
+// Dimension is indexed with an integer, we could use the ToughSlice
+// approach, but this is faster
+
+{
+    Py_ssize_t __pyx_tmp_idx = {{idx}};
 
     {{if wraparound or boundscheck}}
         Py_ssize_t __pyx_tmp_shape = {{src}}.shape[{{dim}}];
     {{endif}}
 
-    Py_ssize_t __pyx_tmp_stride = {{src}}.strides[{{dim}}]; 
+    Py_ssize_t __pyx_tmp_stride = {{src}}.strides[{{dim}}];
     {{if wraparound}}
         if (__pyx_tmp_idx < 0)
             __pyx_tmp_idx += __pyx_tmp_shape;
     {{endif}}
- 
+
     {{if boundscheck}}
         if (unlikely(!__Pyx_is_valid_index(__pyx_tmp_idx, __pyx_tmp_shape))) {
             {{if not have_gil}}
@@ -867,79 +867,79 @@ if (unlikely(__pyx_memoryview_slice_memviewslice(
                 PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
                 #endif
             {{endif}}
- 
+
             PyErr_SetString(PyExc_IndexError,
                             "Index out of bounds (axis {{dim}})");
- 
+
             {{if not have_gil}}
                 #ifdef WITH_THREAD
                 PyGILState_Release(__pyx_gilstate_save);
                 #endif
             {{endif}}
- 
+
             {{error_goto}}
         }
     {{endif}}
- 
-    {{if all_dimensions_direct}} 
-        {{dst}}.data += __pyx_tmp_idx * __pyx_tmp_stride; 
-    {{else}} 
+
+    {{if all_dimensions_direct}}
+        {{dst}}.data += __pyx_tmp_idx * __pyx_tmp_stride;
+    {{else}}
         if ({{get_suboffset_dim()}} < 0) {
-            {{dst}}.data += __pyx_tmp_idx * __pyx_tmp_stride; 
- 
-            /* This dimension is the first dimension, or is preceded by    */ 
-            /* direct or indirect dimensions that are indexed away.        */ 
-            /* Hence suboffset_dim must be less than zero, and we can have */ 
-            /* our data pointer refer to another block by dereferencing.   */ 
-            /*   slice.data -> B -> C     becomes     slice.data -> C      */ 
- 
-            {{if indirect}} 
-              { 
-                Py_ssize_t __pyx_tmp_suboffset = {{src}}.suboffsets[{{dim}}]; 
- 
-                {{if generic}} 
-                    if (__pyx_tmp_suboffset >= 0) 
-                {{endif}} 
- 
-                    {{dst}}.data = *((char **) {{dst}}.data) + __pyx_tmp_suboffset; 
-              } 
-            {{endif}} 
- 
-        } else { 
+            {{dst}}.data += __pyx_tmp_idx * __pyx_tmp_stride;
+
+            /* This dimension is the first dimension, or is preceded by    */
+            /* direct or indirect dimensions that are indexed away.        */
+            /* Hence suboffset_dim must be less than zero, and we can have */
+            /* our data pointer refer to another block by dereferencing.   */
+            /*   slice.data -> B -> C     becomes     slice.data -> C      */
+
+            {{if indirect}}
+              {
+                Py_ssize_t __pyx_tmp_suboffset = {{src}}.suboffsets[{{dim}}];
+
+                {{if generic}}
+                    if (__pyx_tmp_suboffset >= 0)
+                {{endif}}
+
+                    {{dst}}.data = *((char **) {{dst}}.data) + __pyx_tmp_suboffset;
+              }
+            {{endif}}
+
+        } else {
             {{dst}}.suboffsets[{{get_suboffset_dim()}}] += __pyx_tmp_idx * __pyx_tmp_stride;
- 
-            /* Note: dimension can not be indirect, the compiler will have */ 
-            /*       issued an error */ 
-        } 
- 
-    {{endif}} 
-} 
- 
- 
-////////// FillStrided1DScalar.proto ////////// 
- 
-static void 
-__pyx_fill_slice_{{dtype_name}}({{type_decl}} *p, Py_ssize_t extent, Py_ssize_t stride, 
-                                size_t itemsize, void *itemp); 
- 
-////////// FillStrided1DScalar ////////// 
- 
-/* Fill a slice with a scalar value. The dimension is direct and strided or contiguous */ 
-/* This can be used as a callback for the memoryview object to efficienty assign a scalar */ 
-/* Currently unused */ 
-static void 
-__pyx_fill_slice_{{dtype_name}}({{type_decl}} *p, Py_ssize_t extent, Py_ssize_t stride, 
-                                size_t itemsize, void *itemp) 
-{ 
-    Py_ssize_t i; 
-    {{type_decl}} item = *(({{type_decl}} *) itemp); 
-    {{type_decl}} *endp; 
- 
-    stride /= sizeof({{type_decl}}); 
-    endp = p + stride * extent; 
- 
-    while (p < endp) { 
-        *p = item; 
-        p += stride; 
-    } 
-} 
+
+            /* Note: dimension can not be indirect, the compiler will have */
+            /*       issued an error */
+        }
+
+    {{endif}}
+}
+
+
+////////// FillStrided1DScalar.proto //////////
+
+static void
+__pyx_fill_slice_{{dtype_name}}({{type_decl}} *p, Py_ssize_t extent, Py_ssize_t stride,
+                                size_t itemsize, void *itemp);
+
+////////// FillStrided1DScalar //////////
+
+/* Fill a slice with a scalar value. The dimension is direct and strided or contiguous */
+/* This can be used as a callback for the memoryview object to efficienty assign a scalar */
+/* Currently unused */
+static void
+__pyx_fill_slice_{{dtype_name}}({{type_decl}} *p, Py_ssize_t extent, Py_ssize_t stride,
+                                size_t itemsize, void *itemp)
+{
+    Py_ssize_t i;
+    {{type_decl}} item = *(({{type_decl}} *) itemp);
+    {{type_decl}} *endp;
+
+    stride /= sizeof({{type_decl}});
+    endp = p + stride * extent;
+
+    while (p < endp) {
+        *p = item;
+        p += stride;
+    }
+}