numpy 1.9.2__zip → 1.10.0__zip

numpy-1.9.2/numpy/core/src/multiarray/dtype_transfer.c

@@ -1,4232 +0,0 @@
-/*
- * This file contains low-level loops for data type transfers.
- * In particular the function PyArray_GetDTypeTransferFunction is
- * implemented here.
- *
- * Copyright (c) 2010 by Mark Wiebe (mwwiebe@gmail.com)
- * The Univerity of British Columbia
- *
- * See LICENSE.txt for the license.
-
- */
-
-#define PY_SSIZE_T_CLEAN
-#include "Python.h"
-#include "structmember.h"
-
-#define NPY_NO_DEPRECATED_API NPY_API_VERSION
-#define _MULTIARRAYMODULE
-#include <numpy/arrayobject.h>
-#include <numpy/npy_cpu.h>
-
-#include "npy_pycompat.h"
-
-#include "convert_datatype.h"
-#include "_datetime.h"
-#include "datetime_strings.h"
-
-#include "shape.h"
-#include "lowlevel_strided_loops.h"
-
-#define NPY_LOWLEVEL_BUFFER_BLOCKSIZE  128
-
-/********** PRINTF DEBUG TRACING **************/
-#define NPY_DT_DBG_TRACING 0
-/* Tracing incref/decref can be very noisy */
-#define NPY_DT_REF_DBG_TRACING 0
-
-#if NPY_DT_REF_DBG_TRACING
-#define NPY_DT_DBG_REFTRACE(msg, ref) \
-    printf("%-12s %20p %s%d%s\n", msg, ref, \
-                        ref ? "(refcnt " : "", \
-                        ref ? (int)ref->ob_refcnt : 0, \
-                        ref ? ((ref->ob_refcnt <= 0) ? \
-                                        ") <- BIG PROBLEM!!!!" : ")") : ""); \
-    fflush(stdout);
-#else
-#define NPY_DT_DBG_REFTRACE(msg, ref)
-#endif
-/**********************************************/
-
-/*
- * Returns a transfer function which DECREFs any references in src_type.
- *
- * Returns NPY_SUCCEED or NPY_FAIL.
- */
-static int
-get_decsrcref_transfer_function(int aligned,
-                            npy_intp src_stride,
-                            PyArray_Descr *src_dtype,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api);
-
-/*
- * Returns a transfer function which zeros out the dest values.
- *
- * Returns NPY_SUCCEED or NPY_FAIL.
- */
-static int
-get_setdstzero_transfer_function(int aligned,
-                            npy_intp dst_stride,
-                            PyArray_Descr *dst_dtype,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api);
-
-/*
- * Returns a transfer function which sets a boolean type to ones.
- *
- * Returns NPY_SUCCEED or NPY_FAIL.
- */
-NPY_NO_EXPORT int
-get_bool_setdstone_transfer_function(npy_intp dst_stride,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *NPY_UNUSED(out_needs_api));
-
-/*************************** COPY REFERENCES *******************************/
-
-/* Moves references from src to dst */
-static void
-_strided_to_strided_move_references(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    PyObject *src_ref = NULL, *dst_ref = NULL;
-    while (N > 0) {
-        NPY_COPY_PYOBJECT_PTR(&src_ref, src);
-        NPY_COPY_PYOBJECT_PTR(&dst_ref, dst);
-
-        /* Release the reference in dst */
-        NPY_DT_DBG_REFTRACE("dec dst ref", dst_ref);
-        Py_XDECREF(dst_ref);
-        /* Move the reference */
-        NPY_DT_DBG_REFTRACE("move src ref", src_ref);
-        NPY_COPY_PYOBJECT_PTR(dst, &src_ref);
-        /* Set the source reference to NULL */
-        src_ref = NULL;
-        NPY_COPY_PYOBJECT_PTR(src, &src_ref);
-
-        src += src_stride;
-        dst += dst_stride;
-        --N;
-    }
-}
-
-/* Copies references from src to dst */
-static void
-_strided_to_strided_copy_references(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    PyObject *src_ref = NULL, *dst_ref = NULL;
-    while (N > 0) {
-        NPY_COPY_PYOBJECT_PTR(&src_ref, src);
-        NPY_COPY_PYOBJECT_PTR(&dst_ref, dst);
-
-        /* Copy the reference */
-        NPY_DT_DBG_REFTRACE("copy src ref", src_ref);
-        NPY_COPY_PYOBJECT_PTR(dst, &src_ref);
-        /* Claim the reference */
-        Py_XINCREF(src_ref);
-        /* Release the reference in dst */
-        NPY_DT_DBG_REFTRACE("dec dst ref", dst_ref);
-        Py_XDECREF(dst_ref);
-
-        src += src_stride;
-        dst += dst_stride;
-        --N;
-    }
-}
-
-/************************** ZERO-PADDED COPY ******************************/
-
-/* Does a zero-padded copy */
-typedef struct {
-    NpyAuxData base;
-    npy_intp dst_itemsize;
-} _strided_zero_pad_data;
-
-/* zero-padded data copy function */
-static NpyAuxData *_strided_zero_pad_data_clone(NpyAuxData *data)
-{
-    _strided_zero_pad_data *newdata =
-            (_strided_zero_pad_data *)PyArray_malloc(
-                                    sizeof(_strided_zero_pad_data));
-    if (newdata == NULL) {
-        return NULL;
-    }
-
-    memcpy(newdata, data, sizeof(_strided_zero_pad_data));
-
-    return (NpyAuxData *)newdata;
-}
-
-/*
- * Does a strided to strided zero-padded copy for the case where
- * dst_itemsize > src_itemsize
- */
-static void
-_strided_to_strided_zero_pad_copy(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _strided_zero_pad_data *d = (_strided_zero_pad_data *)data;
-    npy_intp dst_itemsize = d->dst_itemsize;
-    npy_intp zero_size = dst_itemsize-src_itemsize;
-
-    while (N > 0) {
-        memcpy(dst, src, src_itemsize);
-        memset(dst + src_itemsize, 0, zero_size);
-        src += src_stride;
-        dst += dst_stride;
-        --N;
-    }
-}
-
-/*
- * Does a strided to strided zero-padded copy for the case where
- * dst_itemsize < src_itemsize
- */
-static void
-_strided_to_strided_truncate_copy(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _strided_zero_pad_data *d = (_strided_zero_pad_data *)data;
-    npy_intp dst_itemsize = d->dst_itemsize;
-
-    while (N > 0) {
-        memcpy(dst, src, dst_itemsize);
-        src += src_stride;
-        dst += dst_stride;
-        --N;
-    }
-}
-
-NPY_NO_EXPORT int
-PyArray_GetStridedZeroPadCopyFn(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            npy_intp src_itemsize, npy_intp dst_itemsize,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata)
-{
-    if (src_itemsize == dst_itemsize) {
-        *out_stransfer = PyArray_GetStridedCopyFn(aligned, src_stride,
-                                dst_stride, src_itemsize);
-        *out_transferdata = NULL;
-        return (*out_stransfer == NULL) ? NPY_FAIL : NPY_SUCCEED;
-    }
-    else {
-        _strided_zero_pad_data *d = PyArray_malloc(
-                                        sizeof(_strided_zero_pad_data));
-        if (d == NULL) {
-            PyErr_NoMemory();
-            return NPY_FAIL;
-        }
-        d->dst_itemsize = dst_itemsize;
-        d->base.free = (NpyAuxData_FreeFunc *)&PyArray_free;
-        d->base.clone = &_strided_zero_pad_data_clone;
-
-        if (src_itemsize < dst_itemsize) {
-            *out_stransfer = &_strided_to_strided_zero_pad_copy;
-        }
-        else {
-            *out_stransfer = &_strided_to_strided_truncate_copy;
-        }
-
-        *out_transferdata = (NpyAuxData *)d;
-        return NPY_SUCCEED;
-    }
-}
-
-/***************** WRAP ALIGNED CONTIGUOUS TRANSFER FUNCTION **************/
-
-/* Wraps a transfer function + data in alignment code */
-typedef struct {
-    NpyAuxData base;
-    PyArray_StridedUnaryOp *wrapped,
-                *tobuffer, *frombuffer;
-    NpyAuxData *wrappeddata, *todata, *fromdata;
-    npy_intp src_itemsize, dst_itemsize;
-    char *bufferin, *bufferout;
-} _align_wrap_data;
-
-/* transfer data free function */
-static void _align_wrap_data_free(NpyAuxData *data)
-{
-    _align_wrap_data *d = (_align_wrap_data *)data;
-    NPY_AUXDATA_FREE(d->wrappeddata);
-    NPY_AUXDATA_FREE(d->todata);
-    NPY_AUXDATA_FREE(d->fromdata);
-    PyArray_free(data);
-}
-
-/* transfer data copy function */
-static NpyAuxData *_align_wrap_data_clone(NpyAuxData *data)
-{
-    _align_wrap_data *d = (_align_wrap_data *)data;
-    _align_wrap_data *newdata;
-    npy_intp basedatasize, datasize;
-
-    /* Round up the structure size to 16-byte boundary */
-    basedatasize = (sizeof(_align_wrap_data)+15)&(-0x10);
-    /* Add space for two low level buffers */
-    datasize = basedatasize +
-                NPY_LOWLEVEL_BUFFER_BLOCKSIZE*d->src_itemsize +
-                NPY_LOWLEVEL_BUFFER_BLOCKSIZE*d->dst_itemsize;
-
-    /* Allocate the data, and populate it */
-    newdata = (_align_wrap_data *)PyArray_malloc(datasize);
-    if (newdata == NULL) {
-        return NULL;
-    }
-    memcpy(newdata, data, basedatasize);
-    newdata->bufferin = (char *)newdata + basedatasize;
-    newdata->bufferout = newdata->bufferin +
-                NPY_LOWLEVEL_BUFFER_BLOCKSIZE*newdata->src_itemsize;
-    if (newdata->wrappeddata != NULL) {
-        newdata->wrappeddata = NPY_AUXDATA_CLONE(d->wrappeddata);
-        if (newdata->wrappeddata == NULL) {
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-    if (newdata->todata != NULL) {
-        newdata->todata = NPY_AUXDATA_CLONE(d->todata);
-        if (newdata->todata == NULL) {
-            NPY_AUXDATA_FREE(newdata->wrappeddata);
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-    if (newdata->fromdata != NULL) {
-        newdata->fromdata = NPY_AUXDATA_CLONE(d->fromdata);
-        if (newdata->fromdata == NULL) {
-            NPY_AUXDATA_FREE(newdata->wrappeddata);
-            NPY_AUXDATA_FREE(newdata->todata);
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-
-    return (NpyAuxData *)newdata;
-}
-
-static void
-_strided_to_strided_contig_align_wrap(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _align_wrap_data *d = (_align_wrap_data *)data;
-    PyArray_StridedUnaryOp *wrapped = d->wrapped,
-            *tobuffer = d->tobuffer,
-            *frombuffer = d->frombuffer;
-    npy_intp inner_src_itemsize = d->src_itemsize,
-             dst_itemsize = d->dst_itemsize;
-    NpyAuxData *wrappeddata = d->wrappeddata,
-            *todata = d->todata,
-            *fromdata = d->fromdata;
-    char *bufferin = d->bufferin, *bufferout = d->bufferout;
-
-    for(;;) {
-        if (N > NPY_LOWLEVEL_BUFFER_BLOCKSIZE) {
-            tobuffer(bufferin, inner_src_itemsize, src, src_stride,
-                                    NPY_LOWLEVEL_BUFFER_BLOCKSIZE,
-                                    src_itemsize, todata);
-            wrapped(bufferout, dst_itemsize, bufferin, inner_src_itemsize,
-                                    NPY_LOWLEVEL_BUFFER_BLOCKSIZE,
-                                    inner_src_itemsize, wrappeddata);
-            frombuffer(dst, dst_stride, bufferout, dst_itemsize,
-                                    NPY_LOWLEVEL_BUFFER_BLOCKSIZE,
-                                    dst_itemsize, fromdata);
-            N -= NPY_LOWLEVEL_BUFFER_BLOCKSIZE;
-            src += NPY_LOWLEVEL_BUFFER_BLOCKSIZE*src_stride;
-            dst += NPY_LOWLEVEL_BUFFER_BLOCKSIZE*dst_stride;
-        }
-        else {
-            tobuffer(bufferin, inner_src_itemsize, src, src_stride, N,
-                                            src_itemsize, todata);
-            wrapped(bufferout, dst_itemsize, bufferin, inner_src_itemsize, N,
-                                            inner_src_itemsize, wrappeddata);
-            frombuffer(dst, dst_stride, bufferout, dst_itemsize, N,
-                                            dst_itemsize, fromdata);
-            return;
-        }
-    }
-}
-
-static void
-_strided_to_strided_contig_align_wrap_init_dest(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _align_wrap_data *d = (_align_wrap_data *)data;
-    PyArray_StridedUnaryOp *wrapped = d->wrapped,
-            *tobuffer = d->tobuffer,
-            *frombuffer = d->frombuffer;
-    npy_intp inner_src_itemsize = d->src_itemsize,
-             dst_itemsize = d->dst_itemsize;
-    NpyAuxData *wrappeddata = d->wrappeddata,
-            *todata = d->todata,
-            *fromdata = d->fromdata;
-    char *bufferin = d->bufferin, *bufferout = d->bufferout;
-
-    for(;;) {
-        if (N > NPY_LOWLEVEL_BUFFER_BLOCKSIZE) {
-            tobuffer(bufferin, inner_src_itemsize, src, src_stride,
-                                    NPY_LOWLEVEL_BUFFER_BLOCKSIZE,
-                                    src_itemsize, todata);
-            memset(bufferout, 0, dst_itemsize*NPY_LOWLEVEL_BUFFER_BLOCKSIZE);
-            wrapped(bufferout, dst_itemsize, bufferin, inner_src_itemsize,
-                                    NPY_LOWLEVEL_BUFFER_BLOCKSIZE,
-                                    inner_src_itemsize, wrappeddata);
-            frombuffer(dst, dst_stride, bufferout, dst_itemsize,
-                                    NPY_LOWLEVEL_BUFFER_BLOCKSIZE,
-                                    dst_itemsize, fromdata);
-            N -= NPY_LOWLEVEL_BUFFER_BLOCKSIZE;
-            src += NPY_LOWLEVEL_BUFFER_BLOCKSIZE*src_stride;
-            dst += NPY_LOWLEVEL_BUFFER_BLOCKSIZE*dst_stride;
-        }
-        else {
-            tobuffer(bufferin, inner_src_itemsize, src, src_stride, N,
-                                            src_itemsize, todata);
-            memset(bufferout, 0, dst_itemsize*N);
-            wrapped(bufferout, dst_itemsize, bufferin, inner_src_itemsize, N,
-                                            inner_src_itemsize, wrappeddata);
-            frombuffer(dst, dst_stride, bufferout, dst_itemsize, N,
-                                            dst_itemsize, fromdata);
-            return;
-        }
-    }
-}
-
-/*
- * Wraps an aligned contig to contig transfer function between either
- * copies or byte swaps to temporary buffers.
- *
- * src_itemsize/dst_itemsize - The sizes of the src and dst datatypes.
- * tobuffer - copy/swap function from src to an aligned contiguous buffer.
- * todata - data for tobuffer
- * frombuffer - copy/swap function from an aligned contiguous buffer to dst.
- * fromdata - data for frombuffer
- * wrapped - contig to contig transfer function being wrapped
- * wrappeddata - data for wrapped
- * init_dest - 1 means to memset the dest buffer to 0 before calling wrapped.
- *
- * Returns NPY_SUCCEED or NPY_FAIL.
- */
-NPY_NO_EXPORT int
-wrap_aligned_contig_transfer_function(
-            npy_intp src_itemsize, npy_intp dst_itemsize,
-            PyArray_StridedUnaryOp *tobuffer, NpyAuxData *todata,
-            PyArray_StridedUnaryOp *frombuffer, NpyAuxData *fromdata,
-            PyArray_StridedUnaryOp *wrapped, NpyAuxData *wrappeddata,
-            int init_dest,
-            PyArray_StridedUnaryOp **out_stransfer,
-            NpyAuxData **out_transferdata)
-{
-    _align_wrap_data *data;
-    npy_intp basedatasize, datasize;
-
-    /* Round up the structure size to 16-byte boundary */
-    basedatasize = (sizeof(_align_wrap_data)+15)&(-0x10);
-    /* Add space for two low level buffers */
-    datasize = basedatasize +
-                NPY_LOWLEVEL_BUFFER_BLOCKSIZE*src_itemsize +
-                NPY_LOWLEVEL_BUFFER_BLOCKSIZE*dst_itemsize;
-
-    /* Allocate the data, and populate it */
-    data = (_align_wrap_data *)PyArray_malloc(datasize);
-    if (data == NULL) {
-        PyErr_NoMemory();
-        return NPY_FAIL;
-    }
-    data->base.free = &_align_wrap_data_free;
-    data->base.clone = &_align_wrap_data_clone;
-    data->tobuffer = tobuffer;
-    data->todata = todata;
-    data->frombuffer = frombuffer;
-    data->fromdata = fromdata;
-    data->wrapped = wrapped;
-    data->wrappeddata = wrappeddata;
-    data->src_itemsize = src_itemsize;
-    data->dst_itemsize = dst_itemsize;
-    data->bufferin = (char *)data + basedatasize;
-    data->bufferout = data->bufferin +
-                NPY_LOWLEVEL_BUFFER_BLOCKSIZE*src_itemsize;
-
-    /* Set the function and data */
-    if (init_dest) {
-        *out_stransfer = &_strided_to_strided_contig_align_wrap_init_dest;
-    }
-    else {
-        *out_stransfer = &_strided_to_strided_contig_align_wrap;
-    }
-    *out_transferdata = (NpyAuxData *)data;
-
-    return NPY_SUCCEED;
-}
-
-/*************************** WRAP DTYPE COPY/SWAP *************************/
-/* Wraps the dtype copy swap function */
-typedef struct {
-    NpyAuxData base;
-    PyArray_CopySwapNFunc *copyswapn;
-    int swap;
-    PyArrayObject *arr;
-} _wrap_copy_swap_data;
-
-/* wrap copy swap data free function */
-static void _wrap_copy_swap_data_free(NpyAuxData *data)
-{
-    _wrap_copy_swap_data *d = (_wrap_copy_swap_data *)data;
-    Py_DECREF(d->arr);
-    PyArray_free(data);
-}
-
-/* wrap copy swap data copy function */
-static NpyAuxData *_wrap_copy_swap_data_clone(NpyAuxData *data)
-{
-    _wrap_copy_swap_data *newdata =
-        (_wrap_copy_swap_data *)PyArray_malloc(sizeof(_wrap_copy_swap_data));
-    if (newdata == NULL) {
-        return NULL;
-    }
-
-    memcpy(newdata, data, sizeof(_wrap_copy_swap_data));
-    Py_INCREF(newdata->arr);
-
-    return (NpyAuxData *)newdata;
-}
-
-static void
-_strided_to_strided_wrap_copy_swap(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *data)
-{
-    _wrap_copy_swap_data *d = (_wrap_copy_swap_data *)data;
-
-    d->copyswapn(dst, dst_stride, src, src_stride, N, d->swap, d->arr);
-}
-
-/* This only gets used for custom data types */
-static int
-wrap_copy_swap_function(int aligned,
-                npy_intp src_stride, npy_intp dst_stride,
-                PyArray_Descr *dtype,
-                int should_swap,
-                PyArray_StridedUnaryOp **out_stransfer,
-                NpyAuxData **out_transferdata)
-{
-    _wrap_copy_swap_data *data;
-    npy_intp shape = 1;
-
-    /* Allocate the data for the copy swap */
-    data = (_wrap_copy_swap_data *)PyArray_malloc(sizeof(_wrap_copy_swap_data));
-    if (data == NULL) {
-        PyErr_NoMemory();
-        *out_stransfer = NULL;
-        *out_transferdata = NULL;
-        return NPY_FAIL;
-    }
-
-    data->base.free = &_wrap_copy_swap_data_free;
-    data->base.clone = &_wrap_copy_swap_data_clone;
-    data->copyswapn = dtype->f->copyswapn;
-    data->swap = should_swap;
-
-    /*
-     * TODO: This is a hack so the copyswap functions have an array.
-     *       The copyswap functions shouldn't need that.
-     */
-    Py_INCREF(dtype);
-    data->arr = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype,
-                            1, &shape, NULL, NULL, 0, NULL);
-    if (data->arr == NULL) {
-        PyArray_free(data);
-        return NPY_FAIL;
-    }
-
-    *out_stransfer = &_strided_to_strided_wrap_copy_swap;
-    *out_transferdata = (NpyAuxData *)data;
-
-    return NPY_SUCCEED;
-}
-
-/*************************** DTYPE CAST FUNCTIONS *************************/
-
-/* Does a simple aligned cast */
-typedef struct {
-    NpyAuxData base;
-    PyArray_VectorUnaryFunc *castfunc;
-    PyArrayObject *aip, *aop;
-} _strided_cast_data;
-
-/* strided cast data free function */
-static void _strided_cast_data_free(NpyAuxData *data)
-{
-    _strided_cast_data *d = (_strided_cast_data *)data;
-    Py_DECREF(d->aip);
-    Py_DECREF(d->aop);
-    PyArray_free(data);
-}
-
-/* strided cast data copy function */
-static NpyAuxData *_strided_cast_data_clone(NpyAuxData *data)
-{
-    _strided_cast_data *newdata =
-            (_strided_cast_data *)PyArray_malloc(sizeof(_strided_cast_data));
-    if (newdata == NULL) {
-        return NULL;
-    }
-
-    memcpy(newdata, data, sizeof(_strided_cast_data));
-    Py_INCREF(newdata->aip);
-    Py_INCREF(newdata->aop);
-
-    return (NpyAuxData *)newdata;
-}
-
-static void
-_aligned_strided_to_strided_cast(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _strided_cast_data *d = (_strided_cast_data *)data;
-    PyArray_VectorUnaryFunc *castfunc = d->castfunc;
-    PyArrayObject *aip = d->aip, *aop = d->aop;
-
-    while (N > 0) {
-        castfunc(src, dst, 1, aip, aop);
-        dst += dst_stride;
-        src += src_stride;
-        --N;
-    }
-}
-
-/* This one requires src be of type NPY_OBJECT */
-static void
-_aligned_strided_to_strided_cast_decref_src(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _strided_cast_data *d = (_strided_cast_data *)data;
-    PyArray_VectorUnaryFunc *castfunc = d->castfunc;
-    PyArrayObject *aip = d->aip, *aop = d->aop;
-    PyObject *src_ref;
-
-    while (N > 0) {
-        castfunc(src, dst, 1, aip, aop);
-
-        /* After casting, decrement the source ref */
-        NPY_COPY_PYOBJECT_PTR(&src_ref, src);
-        NPY_DT_DBG_REFTRACE("dec src ref (cast object -> not object)", src_ref);
-        Py_XDECREF(src_ref);
-
-        dst += dst_stride;
-        src += src_stride;
-        --N;
-    }
-}
-
-static void
-_aligned_contig_to_contig_cast(char *dst, npy_intp NPY_UNUSED(dst_stride),
-                        char *src, npy_intp NPY_UNUSED(src_stride),
-                        npy_intp N, npy_intp NPY_UNUSED(itemsize),
-                        NpyAuxData *data)
-{
-    _strided_cast_data *d = (_strided_cast_data *)data;
-
-    d->castfunc(src, dst, N, d->aip, d->aop);
-}
-
-static int
-get_nbo_cast_numeric_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            int src_type_num, int dst_type_num,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata)
-{
-    /* Emit a warning if complex imaginary is being cast away */
-    if (PyTypeNum_ISCOMPLEX(src_type_num) &&
-                    !PyTypeNum_ISCOMPLEX(dst_type_num) &&
-                    !PyTypeNum_ISBOOL(dst_type_num)) {
-        PyObject *cls = NULL, *obj = NULL;
-        int ret;
-        obj = PyImport_ImportModule("numpy.core");
-        if (obj) {
-            cls = PyObject_GetAttrString(obj, "ComplexWarning");
-            Py_DECREF(obj);
-        }
-        ret = PyErr_WarnEx(cls,
-                "Casting complex values to real discards "
-                "the imaginary part", 1);
-        Py_XDECREF(cls);
-        if (ret < 0) {
-            return NPY_FAIL;
-        }
-    }
-
-    *out_stransfer = PyArray_GetStridedNumericCastFn(aligned,
-                                src_stride, dst_stride,
-                                src_type_num, dst_type_num);
-    *out_transferdata = NULL;
-    if (*out_stransfer == NULL) {
-        PyErr_SetString(PyExc_ValueError,
-                "unexpected error in GetStridedNumericCastFn");
-        return NPY_FAIL;
-    }
-
-    return NPY_SUCCEED;
-}
-
-/*
- * Does a datetime->datetime, timedelta->timedelta,
- * datetime->ascii, or ascii->datetime cast
- */
-typedef struct {
-    NpyAuxData base;
-    /* The conversion fraction */
-    npy_int64 num, denom;
-    /* For the datetime -> string conversion, the dst string length */
-    npy_intp src_itemsize, dst_itemsize;
-    /*
-     * A buffer of size 'src_itemsize + 1', for when the input
-     * string is exactly of length src_itemsize with no NULL
-     * terminator.
-     */
-    char *tmp_buffer;
-    /*
-     * The metadata for when dealing with Months or Years
-     * which behave non-linearly with respect to the other
-     * units.
-     */
-    PyArray_DatetimeMetaData src_meta, dst_meta;
-} _strided_datetime_cast_data;
-
-/* strided datetime cast data free function */
-static void _strided_datetime_cast_data_free(NpyAuxData *data)
-{
-    _strided_datetime_cast_data *d = (_strided_datetime_cast_data *)data;
-    PyArray_free(d->tmp_buffer);
-    PyArray_free(data);
-}
-
-/* strided datetime cast data copy function */
-static NpyAuxData *_strided_datetime_cast_data_clone(NpyAuxData *data)
-{
-    _strided_datetime_cast_data *newdata =
-            (_strided_datetime_cast_data *)PyArray_malloc(
-                                        sizeof(_strided_datetime_cast_data));
-    if (newdata == NULL) {
-        return NULL;
-    }
-
-    memcpy(newdata, data, sizeof(_strided_datetime_cast_data));
-    if (newdata->tmp_buffer != NULL) {
-        newdata->tmp_buffer = PyArray_malloc(newdata->src_itemsize + 1);
-        if (newdata->tmp_buffer == NULL) {
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-
-    return (NpyAuxData *)newdata;
-}
-
-static void
-_strided_to_strided_datetime_general_cast(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _strided_datetime_cast_data *d = (_strided_datetime_cast_data *)data;
-    npy_int64 dt;
-    npy_datetimestruct dts;
-
-    while (N > 0) {
-        memcpy(&dt, src, sizeof(dt));
-
-        if (convert_datetime_to_datetimestruct(&d->src_meta,
-                                               dt, &dts) < 0) {
-            dt = NPY_DATETIME_NAT;
-        }
-        else {
-            if (convert_datetimestruct_to_datetime(&d->dst_meta,
-                                                   &dts, &dt) < 0) {
-                dt = NPY_DATETIME_NAT;
-            }
-        }
-
-        memcpy(dst, &dt, sizeof(dt));
-
-        dst += dst_stride;
-        src += src_stride;
-        --N;
-    }
-}
-
-static void
-_strided_to_strided_datetime_cast(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _strided_datetime_cast_data *d = (_strided_datetime_cast_data *)data;
-    npy_int64 num = d->num, denom = d->denom;
-    npy_int64 dt;
-
-    while (N > 0) {
-        memcpy(&dt, src, sizeof(dt));
-
-        if (dt != NPY_DATETIME_NAT) {
-            /* Apply the scaling */
-            if (dt < 0) {
-                dt = (dt * num - (denom - 1)) / denom;
-            }
-            else {
-                dt = dt * num / denom;
-            }
-        }
-
-        memcpy(dst, &dt, sizeof(dt));
-
-        dst += dst_stride;
-        src += src_stride;
-        --N;
-    }
-}
-
-static void
-_aligned_strided_to_strided_datetime_cast(char *dst,
-                        npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _strided_datetime_cast_data *d = (_strided_datetime_cast_data *)data;
-    npy_int64 num = d->num, denom = d->denom;
-    npy_int64 dt;
-
-    while (N > 0) {
-        dt = *(npy_int64 *)src;
-
-        if (dt != NPY_DATETIME_NAT) {
-            /* Apply the scaling */
-            if (dt < 0) {
-                dt = (dt * num - (denom - 1)) / denom;
-            }
-            else {
-                dt = dt * num / denom;
-            }
-        }
-
-        *(npy_int64 *)dst = dt;
-
-        dst += dst_stride;
-        src += src_stride;
-        --N;
-    }
-}
-
-static void
-_strided_to_strided_datetime_to_string(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *data)
-{
-    _strided_datetime_cast_data *d = (_strided_datetime_cast_data *)data;
-    npy_intp dst_itemsize = d->dst_itemsize;
-    npy_int64 dt;
-    npy_datetimestruct dts;
-
-    while (N > 0) {
-        memcpy(&dt, src, sizeof(dt));
-
-        if (convert_datetime_to_datetimestruct(&d->src_meta,
-                                               dt, &dts) < 0) {
-            /* For an error, produce a 'NaT' string */
-            dts.year = NPY_DATETIME_NAT;
-        }
-
-        /* Initialize the destination to all zeros */
-        memset(dst, 0, dst_itemsize);
-
-        /*
-         * This may also raise an error, but the caller needs
-         * to use PyErr_Occurred().
-         */
-        make_iso_8601_datetime(&dts, dst, dst_itemsize,
-                                0, d->src_meta.base, -1,
-                                NPY_UNSAFE_CASTING);
-
-        dst += dst_stride;
-        src += src_stride;
-        --N;
-    }
-}
-
-static void
-_strided_to_strided_string_to_datetime(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _strided_datetime_cast_data *d = (_strided_datetime_cast_data *)data;
-    npy_datetimestruct dts;
-    char *tmp_buffer = d->tmp_buffer;
-    char *tmp;
-
-    while (N > 0) {
-        npy_int64 dt = ~NPY_DATETIME_NAT;
-
-        /* Replicating strnlen with memchr, because Mac OS X lacks it */
-        tmp = memchr(src, '\0', src_itemsize);
-
-        /* If the string is all full, use the buffer */
-        if (tmp == NULL) {
-            memcpy(tmp_buffer, src, src_itemsize);
-            tmp_buffer[src_itemsize] = '\0';
-
-            if (parse_iso_8601_datetime(tmp_buffer, src_itemsize,
-                                    d->dst_meta.base, NPY_SAME_KIND_CASTING,
-                                    &dts, NULL, NULL, NULL) < 0) {
-                dt = NPY_DATETIME_NAT;
-            }
-        }
-        /* Otherwise parse the data in place */
-        else {
-            if (parse_iso_8601_datetime(src, tmp - src,
-                                    d->dst_meta.base, NPY_SAME_KIND_CASTING,
-                                    &dts, NULL, NULL, NULL) < 0) {
-                dt = NPY_DATETIME_NAT;
-            }
-        }
-
-        /* Convert to the datetime */
-        if (dt != NPY_DATETIME_NAT &&
-                convert_datetimestruct_to_datetime(&d->dst_meta,
-                                               &dts, &dt) < 0) {
-            dt = NPY_DATETIME_NAT;
-        }
-
-        memcpy(dst, &dt, sizeof(dt));
-
-        dst += dst_stride;
-        src += src_stride;
-        --N;
-    }
-}
-
-/*
- * Assumes src_dtype and dst_dtype are both datetimes or both timedeltas
- */
-static int
-get_nbo_cast_datetime_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata)
-{
-    PyArray_DatetimeMetaData *src_meta, *dst_meta;
-    npy_int64 num = 0, denom = 0;
-    _strided_datetime_cast_data *data;
-
-    src_meta = get_datetime_metadata_from_dtype(src_dtype);
-    if (src_meta == NULL) {
-        return NPY_FAIL;
-    }
-    dst_meta = get_datetime_metadata_from_dtype(dst_dtype);
-    if (dst_meta == NULL) {
-        return NPY_FAIL;
-    }
-
-    get_datetime_conversion_factor(src_meta, dst_meta, &num, &denom);
-
-    if (num == 0) {
-        return NPY_FAIL;
-    }
-
-    /* Allocate the data for the casting */
-    data = (_strided_datetime_cast_data *)PyArray_malloc(
-                                    sizeof(_strided_datetime_cast_data));
-    if (data == NULL) {
-        PyErr_NoMemory();
-        *out_stransfer = NULL;
-        *out_transferdata = NULL;
-        return NPY_FAIL;
-    }
-    data->base.free = &_strided_datetime_cast_data_free;
-    data->base.clone = &_strided_datetime_cast_data_clone;
-    data->num = num;
-    data->denom = denom;
-    data->tmp_buffer = NULL;
-
-    /*
-     * Special case the datetime (but not timedelta) with the nonlinear
-     * units (years and months). For timedelta, an average
-     * years and months value is used.
-     */
-    if (src_dtype->type_num == NPY_DATETIME &&
-            (src_meta->base == NPY_FR_Y ||
-             src_meta->base == NPY_FR_M ||
-             dst_meta->base == NPY_FR_Y ||
-             dst_meta->base == NPY_FR_M)) {
-        memcpy(&data->src_meta, src_meta, sizeof(data->src_meta));
-        memcpy(&data->dst_meta, dst_meta, sizeof(data->dst_meta));
-        *out_stransfer = &_strided_to_strided_datetime_general_cast;
-    }
-    else if (aligned) {
-        *out_stransfer = &_aligned_strided_to_strided_datetime_cast;
-    }
-    else {
-        *out_stransfer = &_strided_to_strided_datetime_cast;
-    }
-    *out_transferdata = (NpyAuxData *)data;
-
-#if NPY_DT_DBG_TRACING
-    printf("Dtype transfer from ");
-    PyObject_Print((PyObject *)src_dtype, stdout, 0);
-    printf(" to ");
-    PyObject_Print((PyObject *)dst_dtype, stdout, 0);
-    printf("\n");
-    printf("has conversion fraction %lld/%lld\n", num, denom);
-#endif
-
-
-    return NPY_SUCCEED;
-}
-
-static int
-get_nbo_datetime_to_string_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata)
-{
-    PyArray_DatetimeMetaData *src_meta;
-    _strided_datetime_cast_data *data;
-
-    src_meta = get_datetime_metadata_from_dtype(src_dtype);
-    if (src_meta == NULL) {
-        return NPY_FAIL;
-    }
-
-    /* Allocate the data for the casting */
-    data = (_strided_datetime_cast_data *)PyArray_malloc(
-                                    sizeof(_strided_datetime_cast_data));
-    if (data == NULL) {
-        PyErr_NoMemory();
-        *out_stransfer = NULL;
-        *out_transferdata = NULL;
-        return NPY_FAIL;
-    }
-    data->base.free = &_strided_datetime_cast_data_free;
-    data->base.clone = &_strided_datetime_cast_data_clone;
-    data->dst_itemsize = dst_dtype->elsize;
-    data->tmp_buffer = NULL;
-
-    memcpy(&data->src_meta, src_meta, sizeof(data->src_meta));
-
-    *out_stransfer = &_strided_to_strided_datetime_to_string;
-    *out_transferdata = (NpyAuxData *)data;
-
-#if NPY_DT_DBG_TRACING
-    printf("Dtype transfer from ");
-    PyObject_Print((PyObject *)src_dtype, stdout, 0);
-    printf(" to ");
-    PyObject_Print((PyObject *)dst_dtype, stdout, 0);
-    printf("\n");
-#endif
-
-    return NPY_SUCCEED;
-}
-
-static int
-get_datetime_to_unicode_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    NpyAuxData *castdata = NULL, *todata = NULL, *fromdata = NULL;
-    PyArray_StridedUnaryOp *caststransfer, *tobuffer, *frombuffer;
-    PyArray_Descr *str_dtype;
-
-    /* Get an ASCII string data type, adapted to match the UNICODE one */
-    str_dtype = PyArray_DescrFromType(NPY_STRING);
-    PyArray_AdaptFlexibleDType(NULL, dst_dtype, &str_dtype);
-    if (str_dtype == NULL) {
-        return NPY_FAIL;
-    }
-
-    /* Get the copy/swap operation to dst */
-    if (PyArray_GetDTypeCopySwapFn(aligned,
-                            src_stride, src_dtype->elsize,
-                            src_dtype,
-                            &tobuffer, &todata) != NPY_SUCCEED) {
-        Py_DECREF(str_dtype);
-        return NPY_FAIL;
-    }
-
-    /* Get the NBO datetime to string aligned contig function */
-    if (get_nbo_datetime_to_string_transfer_function(1,
-                            src_dtype->elsize, str_dtype->elsize,
-                            src_dtype, str_dtype,
-                            &caststransfer, &castdata) != NPY_SUCCEED) {
-        Py_DECREF(str_dtype);
-        NPY_AUXDATA_FREE(todata);
-        return NPY_FAIL;
-    }
-
-    /* Get the cast operation to dst */
-    if (PyArray_GetDTypeTransferFunction(aligned,
-                            str_dtype->elsize, dst_stride,
-                            str_dtype, dst_dtype,
-                            0,
-                            &frombuffer, &fromdata,
-                            out_needs_api) != NPY_SUCCEED) {
-        Py_DECREF(str_dtype);
-        NPY_AUXDATA_FREE(todata);
-        NPY_AUXDATA_FREE(castdata);
-        return NPY_FAIL;
-    }
-
-    /* Wrap it all up in a new transfer function + data */
-    if (wrap_aligned_contig_transfer_function(
-                        src_dtype->elsize, str_dtype->elsize,
-                        tobuffer, todata,
-                        frombuffer, fromdata,
-                        caststransfer, castdata,
-                        PyDataType_FLAGCHK(str_dtype, NPY_NEEDS_INIT),
-                        out_stransfer, out_transferdata) != NPY_SUCCEED) {
-        NPY_AUXDATA_FREE(castdata);
-        NPY_AUXDATA_FREE(todata);
-        NPY_AUXDATA_FREE(fromdata);
-        return NPY_FAIL;
-    }
-
-    Py_DECREF(str_dtype);
-
-    return NPY_SUCCEED;
-}
-
-static int
-get_nbo_string_to_datetime_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata)
-{
-    PyArray_DatetimeMetaData *dst_meta;
-    _strided_datetime_cast_data *data;
-
-    dst_meta = get_datetime_metadata_from_dtype(dst_dtype);
-    if (dst_meta == NULL) {
-        return NPY_FAIL;
-    }
-
-    /* Allocate the data for the casting */
-    data = (_strided_datetime_cast_data *)PyArray_malloc(
-                                    sizeof(_strided_datetime_cast_data));
-    if (data == NULL) {
-        PyErr_NoMemory();
-        *out_stransfer = NULL;
-        *out_transferdata = NULL;
-        return NPY_FAIL;
-    }
-    data->base.free = &_strided_datetime_cast_data_free;
-    data->base.clone = &_strided_datetime_cast_data_clone;
-    data->src_itemsize = src_dtype->elsize;
-    data->tmp_buffer = PyArray_malloc(data->src_itemsize + 1);
-    if (data->tmp_buffer == NULL) {
-        PyErr_NoMemory();
-        PyArray_free(data);
-        *out_stransfer = NULL;
-        *out_transferdata = NULL;
-        return NPY_FAIL;
-    }
-
-    memcpy(&data->dst_meta, dst_meta, sizeof(data->dst_meta));
-
-    *out_stransfer = &_strided_to_strided_string_to_datetime;
-    *out_transferdata = (NpyAuxData *)data;
-
-#if NPY_DT_DBG_TRACING
-    printf("Dtype transfer from ");
-    PyObject_Print((PyObject *)src_dtype, stdout, 0);
-    printf(" to ");
-    PyObject_Print((PyObject *)dst_dtype, stdout, 0);
-    printf("\n");
-#endif
-
-    return NPY_SUCCEED;
-}
-
-static int
-get_unicode_to_datetime_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    NpyAuxData *castdata = NULL, *todata = NULL, *fromdata = NULL;
-    PyArray_StridedUnaryOp *caststransfer, *tobuffer, *frombuffer;
-    PyArray_Descr *str_dtype;
-
-    /* Get an ASCII string data type, adapted to match the UNICODE one */
-    str_dtype = PyArray_DescrFromType(NPY_STRING);
-    PyArray_AdaptFlexibleDType(NULL, src_dtype, &str_dtype);
-    if (str_dtype == NULL) {
-        return NPY_FAIL;
-    }
-
-    /* Get the cast operation from src */
-    if (PyArray_GetDTypeTransferFunction(aligned,
-                            src_stride, str_dtype->elsize,
-                            src_dtype, str_dtype,
-                            0,
-                            &tobuffer, &todata,
-                            out_needs_api) != NPY_SUCCEED) {
-        Py_DECREF(str_dtype);
-        return NPY_FAIL;
-    }
-
-    /* Get the string to NBO datetime aligned contig function */
-    if (get_nbo_string_to_datetime_transfer_function(1,
-                            str_dtype->elsize, dst_dtype->elsize,
-                            str_dtype, dst_dtype,
-                            &caststransfer, &castdata) != NPY_SUCCEED) {
-        Py_DECREF(str_dtype);
-        NPY_AUXDATA_FREE(todata);
-        return NPY_FAIL;
-    }
-
-    /* Get the copy/swap operation to dst */
-    if (PyArray_GetDTypeCopySwapFn(aligned,
-                            dst_dtype->elsize, dst_stride,
-                            dst_dtype,
-                            &frombuffer, &fromdata) != NPY_SUCCEED) {
-        Py_DECREF(str_dtype);
-        NPY_AUXDATA_FREE(todata);
-        NPY_AUXDATA_FREE(castdata);
-        return NPY_FAIL;
-    }
-
-    /* Wrap it all up in a new transfer function + data */
-    if (wrap_aligned_contig_transfer_function(
-                        str_dtype->elsize, dst_dtype->elsize,
-                        tobuffer, todata,
-                        frombuffer, fromdata,
-                        caststransfer, castdata,
-                        PyDataType_FLAGCHK(dst_dtype, NPY_NEEDS_INIT),
-                        out_stransfer, out_transferdata) != NPY_SUCCEED) {
-        Py_DECREF(str_dtype);
-        NPY_AUXDATA_FREE(castdata);
-        NPY_AUXDATA_FREE(todata);
-        NPY_AUXDATA_FREE(fromdata);
-        return NPY_FAIL;
-    }
-
-    Py_DECREF(str_dtype);
-
-    return NPY_SUCCEED;
-}
-
-static int
-get_nbo_cast_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            int move_references,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api,
-                            int *out_needs_wrap)
-{
-    _strided_cast_data *data;
-    PyArray_VectorUnaryFunc *castfunc;
-    PyArray_Descr *tmp_dtype;
-    npy_intp shape = 1, src_itemsize = src_dtype->elsize,
-            dst_itemsize = dst_dtype->elsize;
-
-    if (PyTypeNum_ISNUMBER(src_dtype->type_num) &&
-                    PyTypeNum_ISNUMBER(dst_dtype->type_num)) {
-        *out_needs_wrap = !PyArray_ISNBO(src_dtype->byteorder) ||
-                          !PyArray_ISNBO(dst_dtype->byteorder);
-        return get_nbo_cast_numeric_transfer_function(aligned,
-                                    src_stride, dst_stride,
-                                    src_dtype->type_num, dst_dtype->type_num,
-                                    out_stransfer, out_transferdata);
-    }
-
-    if (src_dtype->type_num == NPY_DATETIME ||
-            src_dtype->type_num == NPY_TIMEDELTA ||
-            dst_dtype->type_num == NPY_DATETIME ||
-            dst_dtype->type_num == NPY_TIMEDELTA) {
-        /* A parameterized type, datetime->datetime sometimes needs casting */
-        if ((src_dtype->type_num == NPY_DATETIME &&
-                    dst_dtype->type_num == NPY_DATETIME) ||
-                (src_dtype->type_num == NPY_TIMEDELTA &&
-                    dst_dtype->type_num == NPY_TIMEDELTA)) {
-            *out_needs_wrap = !PyArray_ISNBO(src_dtype->byteorder) ||
-                              !PyArray_ISNBO(dst_dtype->byteorder);
-            return get_nbo_cast_datetime_transfer_function(aligned,
-                                        src_stride, dst_stride,
-                                        src_dtype, dst_dtype,
-                                        out_stransfer, out_transferdata);
-        }
-
-        /*
-         * Datetime <-> string conversions can be handled specially.
-         * The functions may raise an error if the strings have no
-         * space, or can't be parsed properly.
-         */
-        if (src_dtype->type_num == NPY_DATETIME) {
-            switch (dst_dtype->type_num) {
-                case NPY_STRING:
-                    *out_needs_api = 1;
-                    *out_needs_wrap = !PyArray_ISNBO(src_dtype->byteorder);
-                    return get_nbo_datetime_to_string_transfer_function(
-                                        aligned,
-                                        src_stride, dst_stride,
-                                        src_dtype, dst_dtype,
-                                        out_stransfer, out_transferdata);
-
-                case NPY_UNICODE:
-                    return get_datetime_to_unicode_transfer_function(
-                                        aligned,
-                                        src_stride, dst_stride,
-                                        src_dtype, dst_dtype,
-                                        out_stransfer, out_transferdata,
-                                        out_needs_api);
-            }
-        }
-        else if (dst_dtype->type_num == NPY_DATETIME) {
-            switch (src_dtype->type_num) {
-                case NPY_STRING:
-                    *out_needs_api = 1;
-                    *out_needs_wrap = !PyArray_ISNBO(dst_dtype->byteorder);
-                    return get_nbo_string_to_datetime_transfer_function(
-                                        aligned,
-                                        src_stride, dst_stride,
-                                        src_dtype, dst_dtype,
-                                        out_stransfer, out_transferdata);
-
-                case NPY_UNICODE:
-                    return get_unicode_to_datetime_transfer_function(
-                                        aligned,
-                                        src_stride, dst_stride,
-                                        src_dtype, dst_dtype,
-                                        out_stransfer, out_transferdata,
-                                        out_needs_api);
-            }
-        }
-    }
-
-    *out_needs_wrap = !aligned ||
-                      !PyArray_ISNBO(src_dtype->byteorder) ||
-                      !PyArray_ISNBO(dst_dtype->byteorder);
-
-    /* Check the data types whose casting functions use API calls */
-    switch (src_dtype->type_num) {
-        case NPY_OBJECT:
-        case NPY_STRING:
-        case NPY_UNICODE:
-        case NPY_VOID:
-            if (out_needs_api) {
-                *out_needs_api = 1;
-            }
-            break;
-    }
-    switch (dst_dtype->type_num) {
-        case NPY_OBJECT:
-        case NPY_STRING:
-        case NPY_UNICODE:
-        case NPY_VOID:
-            if (out_needs_api) {
-                *out_needs_api = 1;
-            }
-            break;
-    }
-
-    /* Get the cast function */
-    castfunc = PyArray_GetCastFunc(src_dtype, dst_dtype->type_num);
-    if (!castfunc) {
-        *out_stransfer = NULL;
-        *out_transferdata = NULL;
-        return NPY_FAIL;
-    }
-
-    /* Allocate the data for the casting */
-    data = (_strided_cast_data *)PyArray_malloc(sizeof(_strided_cast_data));
-    if (data == NULL) {
-        PyErr_NoMemory();
-        *out_stransfer = NULL;
-        *out_transferdata = NULL;
-        return NPY_FAIL;
-    }
-    data->base.free = &_strided_cast_data_free;
-    data->base.clone = &_strided_cast_data_clone;
-    data->castfunc = castfunc;
-    /*
-     * TODO: This is a hack so the cast functions have an array.
-     *       The cast functions shouldn't need that.  Also, since we
-     *       always handle byte order conversions, this array should
-     *       have native byte order.
-     */
-    if (PyArray_ISNBO(src_dtype->byteorder)) {
-        tmp_dtype = src_dtype;
-        Py_INCREF(tmp_dtype);
-    }
-    else {
-        tmp_dtype = PyArray_DescrNewByteorder(src_dtype, NPY_NATIVE);
-        if (tmp_dtype == NULL) {
-            PyArray_free(data);
-            return NPY_FAIL;
-        }
-    }
-    data->aip = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, tmp_dtype,
-                            1, &shape, NULL, NULL, 0, NULL);
-    if (data->aip == NULL) {
-        PyArray_free(data);
-        return NPY_FAIL;
-    }
-    /*
-     * TODO: This is a hack so the cast functions have an array.
-     *       The cast functions shouldn't need that.  Also, since we
-     *       always handle byte order conversions, this array should
-     *       have native byte order.
-     */
-    if (PyArray_ISNBO(dst_dtype->byteorder)) {
-        tmp_dtype = dst_dtype;
-        Py_INCREF(tmp_dtype);
-    }
-    else {
-        tmp_dtype = PyArray_DescrNewByteorder(dst_dtype, NPY_NATIVE);
-        if (tmp_dtype == NULL) {
-            Py_DECREF(data->aip);
-            PyArray_free(data);
-            return NPY_FAIL;
-        }
-    }
-    data->aop = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, tmp_dtype,
-                            1, &shape, NULL, NULL, 0, NULL);
-    if (data->aop == NULL) {
-        Py_DECREF(data->aip);
-        PyArray_free(data);
-        return NPY_FAIL;
-    }
-
-    /* If it's aligned and all native byte order, we're all done */
-    if (move_references && src_dtype->type_num == NPY_OBJECT) {
-        *out_stransfer = _aligned_strided_to_strided_cast_decref_src;
-    }
-    else {
-        /*
-         * Use the contig version if the strides are contiguous or
-         * we're telling the caller to wrap the return, because
-         * the wrapping uses a contiguous buffer.
-         */
-        if ((src_stride == src_itemsize && dst_stride == dst_itemsize) ||
-                        *out_needs_wrap) {
-            *out_stransfer = _aligned_contig_to_contig_cast;
-        }
-        else {
-            *out_stransfer = _aligned_strided_to_strided_cast;
-        }
-    }
-    *out_transferdata = (NpyAuxData *)data;
-
-    return NPY_SUCCEED;
-}
-
-static int
-get_cast_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            int move_references,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    PyArray_StridedUnaryOp *caststransfer;
-    NpyAuxData *castdata, *todata = NULL, *fromdata = NULL;
-    int needs_wrap = 0;
-    npy_intp src_itemsize = src_dtype->elsize,
-            dst_itemsize = dst_dtype->elsize;
-
-    if (get_nbo_cast_transfer_function(aligned,
-                            src_stride, dst_stride,
-                            src_dtype, dst_dtype,
-                            move_references,
-                            &caststransfer,
-                            &castdata,
-                            out_needs_api,
-                            &needs_wrap) != NPY_SUCCEED) {
-        return NPY_FAIL;
-    }
-
-    /*
-     * If all native byte order and doesn't need alignment wrapping,
-     * return the function
-     */
-    if (!needs_wrap) {
-        *out_stransfer = caststransfer;
-        *out_transferdata = castdata;
-
-        return NPY_SUCCEED;
-    }
-    /* Otherwise, we have to copy and/or swap to aligned temporaries */
-    else {
-        PyArray_StridedUnaryOp *tobuffer, *frombuffer;
-
-        /* Get the copy/swap operation from src */
-        PyArray_GetDTypeCopySwapFn(aligned,
-                                src_stride, src_itemsize,
-                                src_dtype,
-                                &tobuffer, &todata);
-
-
-        /* Get the copy/swap operation to dst */
-        PyArray_GetDTypeCopySwapFn(aligned,
-                                dst_itemsize, dst_stride,
-                                dst_dtype,
-                                &frombuffer, &fromdata);
-
-        if (frombuffer == NULL || tobuffer == NULL) {
-            NPY_AUXDATA_FREE(castdata);
-            NPY_AUXDATA_FREE(todata);
-            NPY_AUXDATA_FREE(fromdata);
-            return NPY_FAIL;
-        }
-
-        *out_stransfer = caststransfer;
-
-        /* Wrap it all up in a new transfer function + data */
-        if (wrap_aligned_contig_transfer_function(
-                            src_itemsize, dst_itemsize,
-                            tobuffer, todata,
-                            frombuffer, fromdata,
-                            caststransfer, castdata,
-                            PyDataType_FLAGCHK(dst_dtype, NPY_NEEDS_INIT),
-                            out_stransfer, out_transferdata) != NPY_SUCCEED) {
-            NPY_AUXDATA_FREE(castdata);
-            NPY_AUXDATA_FREE(todata);
-            NPY_AUXDATA_FREE(fromdata);
-            return NPY_FAIL;
-        }
-
-        return NPY_SUCCEED;
-    }
-}
-
-/**************************** COPY 1 TO N CONTIGUOUS ************************/
-
-/* Copies 1 element to N contiguous elements */
-typedef struct {
-    NpyAuxData base;
-    PyArray_StridedUnaryOp *stransfer;
-    NpyAuxData *data;
-    npy_intp N, dst_itemsize;
-    /* If this is non-NULL the source type has references needing a decref */
-    PyArray_StridedUnaryOp *stransfer_finish_src;
-    NpyAuxData *data_finish_src;
-} _one_to_n_data;
-
-/* transfer data free function */
-static void _one_to_n_data_free(NpyAuxData *data)
-{
-    _one_to_n_data *d = (_one_to_n_data *)data;
-    NPY_AUXDATA_FREE(d->data);
-    NPY_AUXDATA_FREE(d->data_finish_src);
-    PyArray_free(data);
-}
-
-/* transfer data copy function */
-static NpyAuxData *_one_to_n_data_clone(NpyAuxData *data)
-{
-    _one_to_n_data *d = (_one_to_n_data *)data;
-    _one_to_n_data *newdata;
-
-    /* Allocate the data, and populate it */
-    newdata = (_one_to_n_data *)PyArray_malloc(sizeof(_one_to_n_data));
-    if (newdata == NULL) {
-        return NULL;
-    }
-    memcpy(newdata, data, sizeof(_one_to_n_data));
-    if (d->data != NULL) {
-        newdata->data = NPY_AUXDATA_CLONE(d->data);
-        if (newdata->data == NULL) {
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-    if (d->data_finish_src != NULL) {
-        newdata->data_finish_src = NPY_AUXDATA_CLONE(d->data_finish_src);
-        if (newdata->data_finish_src == NULL) {
-            NPY_AUXDATA_FREE(newdata->data);
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-
-    return (NpyAuxData *)newdata;
-}
-
-static void
-_strided_to_strided_one_to_n(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _one_to_n_data *d = (_one_to_n_data *)data;
-    PyArray_StridedUnaryOp *subtransfer = d->stransfer;
-    NpyAuxData *subdata = d->data;
-    npy_intp subN = d->N, dst_itemsize = d->dst_itemsize;
-
-    while (N > 0) {
-        subtransfer(dst, dst_itemsize,
-                    src, 0,
-                    subN, src_itemsize,
-                    subdata);
-
-        src += src_stride;
-        dst += dst_stride;
-        --N;
-    }
-}
-
-static void
-_strided_to_strided_one_to_n_with_finish(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _one_to_n_data *d = (_one_to_n_data *)data;
-    PyArray_StridedUnaryOp *subtransfer = d->stransfer,
-                *stransfer_finish_src = d->stransfer_finish_src;
-    NpyAuxData *subdata = d->data, *data_finish_src = d->data_finish_src;
-    npy_intp subN = d->N, dst_itemsize = d->dst_itemsize;
-
-    while (N > 0) {
-        subtransfer(dst, dst_itemsize,
-                    src, 0,
-                    subN, src_itemsize,
-                    subdata);
-
-
-        stransfer_finish_src(NULL, 0,
-                            src, 0,
-                            1, src_itemsize,
-                            data_finish_src);
-
-        src += src_stride;
-        dst += dst_stride;
-        --N;
-    }
-}
-
-/*
- * Wraps a transfer function to produce one that copies one element
- * of src to N contiguous elements of dst.  If stransfer_finish_src is
- * not NULL, it should be a transfer function which just affects
- * src, for example to do a final DECREF operation for references.
- */
-static int
-wrap_transfer_function_one_to_n(
-                            PyArray_StridedUnaryOp *stransfer_inner,
-                            NpyAuxData *data_inner,
-                            PyArray_StridedUnaryOp *stransfer_finish_src,
-                            NpyAuxData *data_finish_src,
-                            npy_intp dst_itemsize,
-                            npy_intp N,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata)
-{
-    _one_to_n_data *data;
-
-
-    data = PyArray_malloc(sizeof(_one_to_n_data));
-    if (data == NULL) {
-        PyErr_NoMemory();
-        return NPY_FAIL;
-    }
-
-    data->base.free = &_one_to_n_data_free;
-    data->base.clone = &_one_to_n_data_clone;
-    data->stransfer = stransfer_inner;
-    data->data = data_inner;
-    data->stransfer_finish_src = stransfer_finish_src;
-    data->data_finish_src = data_finish_src;
-    data->N = N;
-    data->dst_itemsize = dst_itemsize;
-
-    if (stransfer_finish_src == NULL) {
-        *out_stransfer = &_strided_to_strided_one_to_n;
-    }
-    else {
-        *out_stransfer = &_strided_to_strided_one_to_n_with_finish;
-    }
-    *out_transferdata = (NpyAuxData *)data;
-
-    return NPY_SUCCEED;
-}
-
-static int
-get_one_to_n_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            int move_references,
-                            npy_intp N,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    PyArray_StridedUnaryOp *stransfer, *stransfer_finish_src = NULL;
-    NpyAuxData *data, *data_finish_src = NULL;
-
-    /*
-     * move_references is set to 0, handled in the wrapping transfer fn,
-     * src_stride is set to zero, because its 1 to N copying,
-     * and dst_stride is set to contiguous, because subarrays are always
-     * contiguous.
-     */
-    if (PyArray_GetDTypeTransferFunction(aligned,
-                    0, dst_dtype->elsize,
-                    src_dtype, dst_dtype,
-                    0,
-                    &stransfer, &data,
-                    out_needs_api) != NPY_SUCCEED) {
-        return NPY_FAIL;
-    }
-
-    /* If the src object will need a DECREF, set src_dtype */
-    if (move_references && PyDataType_REFCHK(src_dtype)) {
-        if (get_decsrcref_transfer_function(aligned,
-                            src_stride,
-                            src_dtype,
-                            &stransfer_finish_src,
-                            &data_finish_src,
-                            out_needs_api) != NPY_SUCCEED) {
-            NPY_AUXDATA_FREE(data);
-            return NPY_FAIL;
-        }
-    }
-
-    if (wrap_transfer_function_one_to_n(stransfer, data,
-                            stransfer_finish_src, data_finish_src,
-                            dst_dtype->elsize,
-                            N,
-                            out_stransfer, out_transferdata) != NPY_SUCCEED) {
-        NPY_AUXDATA_FREE(data);
-        NPY_AUXDATA_FREE(data_finish_src);
-        return NPY_FAIL;
-    }
-
-    return NPY_SUCCEED;
-}
-
-/**************************** COPY N TO N CONTIGUOUS ************************/
-
-/* Copies N contiguous elements to N contiguous elements */
-typedef struct {
-    NpyAuxData base;
-    PyArray_StridedUnaryOp *stransfer;
-    NpyAuxData *data;
-    npy_intp N, src_itemsize, dst_itemsize;
-} _n_to_n_data;
-
-/* transfer data free function */
-static void _n_to_n_data_free(NpyAuxData *data)
-{
-    _n_to_n_data *d = (_n_to_n_data *)data;
-    NPY_AUXDATA_FREE(d->data);
-    PyArray_free(data);
-}
-
-/* transfer data copy function */
-static NpyAuxData *_n_to_n_data_clone(NpyAuxData *data)
-{
-    _n_to_n_data *d = (_n_to_n_data *)data;
-    _n_to_n_data *newdata;
-
-    /* Allocate the data, and populate it */
-    newdata = (_n_to_n_data *)PyArray_malloc(sizeof(_n_to_n_data));
-    if (newdata == NULL) {
-        return NULL;
-    }
-    memcpy(newdata, data, sizeof(_n_to_n_data));
-    if (newdata->data != NULL) {
-        newdata->data = NPY_AUXDATA_CLONE(d->data);
-        if (newdata->data == NULL) {
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-
-    return (NpyAuxData *)newdata;
-}
-
-static void
-_strided_to_strided_n_to_n(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp src_itemsize,
-                        NpyAuxData *data)
-{
-    _n_to_n_data *d = (_n_to_n_data *)data;
-    PyArray_StridedUnaryOp *subtransfer = d->stransfer;
-    NpyAuxData *subdata = d->data;
-    npy_intp subN = d->N, src_subitemsize = d->src_itemsize,
-                dst_subitemsize = d->dst_itemsize;
-
-    while (N > 0) {
-        subtransfer(dst, dst_subitemsize,
-                    src, src_subitemsize,
-                    subN, src_subitemsize,
-                    subdata);
-
-        src += src_stride;
-        dst += dst_stride;
-        --N;
-    }
-}
-
-static void
-_contig_to_contig_n_to_n(char *dst, npy_intp NPY_UNUSED(dst_stride),
-                        char *src, npy_intp NPY_UNUSED(src_stride),
-                        npy_intp N, npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *data)
-{
-    _n_to_n_data *d = (_n_to_n_data *)data;
-    PyArray_StridedUnaryOp *subtransfer = d->stransfer;
-    NpyAuxData *subdata = d->data;
-    npy_intp subN = d->N, src_subitemsize = d->src_itemsize,
-                dst_subitemsize = d->dst_itemsize;
-
-    subtransfer(dst, dst_subitemsize,
-                src, src_subitemsize,
-                subN*N, src_subitemsize,
-                subdata);
-}
-
-/*
- * Wraps a transfer function to produce one that copies N contiguous elements
- * of src to N contiguous elements of dst.
- */
-static int
-wrap_transfer_function_n_to_n(
-                            PyArray_StridedUnaryOp *stransfer_inner,
-                            NpyAuxData *data_inner,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            npy_intp src_itemsize, npy_intp dst_itemsize,
-                            npy_intp N,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata)
-{
-    _n_to_n_data *data;
-
-    data = PyArray_malloc(sizeof(_n_to_n_data));
-    if (data == NULL) {
-        PyErr_NoMemory();
-        return NPY_FAIL;
-    }
-
-    data->base.free = &_n_to_n_data_free;
-    data->base.clone = &_n_to_n_data_clone;
-    data->stransfer = stransfer_inner;
-    data->data = data_inner;
-    data->N = N;
-    data->src_itemsize = src_itemsize;
-    data->dst_itemsize = dst_itemsize;
-
-    /*
-     * If the N subarray elements exactly fit in the strides,
-     * then can do a faster contiguous transfer.
-     */
-    if (src_stride == N * src_itemsize &&
-                    dst_stride == N * dst_itemsize) {
-        *out_stransfer = &_contig_to_contig_n_to_n;
-    }
-    else {
-        *out_stransfer = &_strided_to_strided_n_to_n;
-    }
-    *out_transferdata = (NpyAuxData *)data;
-
-    return NPY_SUCCEED;
-}
-
-static int
-get_n_to_n_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            int move_references,
-                            npy_intp N,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    PyArray_StridedUnaryOp *stransfer;
-    NpyAuxData *data;
-
-    /*
-     * src_stride and dst_stride are set to contiguous, because
-     * subarrays are always contiguous.
-     */
-    if (PyArray_GetDTypeTransferFunction(aligned,
-                    src_dtype->elsize, dst_dtype->elsize,
-                    src_dtype, dst_dtype,
-                    move_references,
-                    &stransfer, &data,
-                    out_needs_api) != NPY_SUCCEED) {
-        return NPY_FAIL;
-    }
-
-    if (wrap_transfer_function_n_to_n(stransfer, data,
-                            src_stride, dst_stride,
-                            src_dtype->elsize, dst_dtype->elsize,
-                            N,
-                            out_stransfer,
-                            out_transferdata) != NPY_SUCCEED) {
-        NPY_AUXDATA_FREE(data);
-        return NPY_FAIL;
-    }
-
-    return NPY_SUCCEED;
-}
-
-/********************** COPY WITH SUBARRAY BROADCAST ************************/
-
-typedef struct {
-    npy_intp offset, count;
-} _subarray_broadcast_offsetrun;
-
-/* Copies element with subarray broadcasting */
-typedef struct {
-    NpyAuxData base;
-    PyArray_StridedUnaryOp *stransfer;
-    NpyAuxData *data;
-    npy_intp src_N, dst_N, src_itemsize, dst_itemsize;
-    PyArray_StridedUnaryOp *stransfer_decsrcref;
-    NpyAuxData *data_decsrcref;
-    PyArray_StridedUnaryOp *stransfer_decdstref;
-    NpyAuxData *data_decdstref;
-    /* This gets a run-length encoded representation of the transfer */
-    npy_intp run_count;
-    _subarray_broadcast_offsetrun offsetruns;
-} _subarray_broadcast_data;
-
-/* transfer data free function */
-static void _subarray_broadcast_data_free(NpyAuxData *data)
-{
-    _subarray_broadcast_data *d = (_subarray_broadcast_data *)data;
-    NPY_AUXDATA_FREE(d->data);
-    NPY_AUXDATA_FREE(d->data_decsrcref);
-    NPY_AUXDATA_FREE(d->data_decdstref);
-    PyArray_free(data);
-}
-
-/* transfer data copy function */
-static NpyAuxData *_subarray_broadcast_data_clone( NpyAuxData *data)
-{
-    _subarray_broadcast_data *d = (_subarray_broadcast_data *)data;
-    _subarray_broadcast_data *newdata;
-    npy_intp run_count = d->run_count, structsize;
-
-    structsize = sizeof(_subarray_broadcast_data) +
-                        run_count*sizeof(_subarray_broadcast_offsetrun);
-
-    /* Allocate the data and populate it */
-    newdata = (_subarray_broadcast_data *)PyArray_malloc(structsize);
-    if (newdata == NULL) {
-        return NULL;
-    }
-    memcpy(newdata, data, structsize);
-    if (d->data != NULL) {
-        newdata->data = NPY_AUXDATA_CLONE(d->data);
-        if (newdata->data == NULL) {
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-    if (d->data_decsrcref != NULL) {
-        newdata->data_decsrcref = NPY_AUXDATA_CLONE(d->data_decsrcref);
-        if (newdata->data_decsrcref == NULL) {
-            NPY_AUXDATA_FREE(newdata->data);
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-    if (d->data_decdstref != NULL) {
-        newdata->data_decdstref = NPY_AUXDATA_CLONE(d->data_decdstref);
-        if (newdata->data_decdstref == NULL) {
-            NPY_AUXDATA_FREE(newdata->data);
-            NPY_AUXDATA_FREE(newdata->data_decsrcref);
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-
-    return (NpyAuxData *)newdata;
-}
-
-static void
-_strided_to_strided_subarray_broadcast(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *data)
-{
-    _subarray_broadcast_data *d = (_subarray_broadcast_data *)data;
-    PyArray_StridedUnaryOp *subtransfer = d->stransfer;
-    NpyAuxData *subdata = d->data;
-    npy_intp run, run_count = d->run_count,
-            src_subitemsize = d->src_itemsize,
-            dst_subitemsize = d->dst_itemsize;
-    npy_intp loop_index, offset, count;
-    char *dst_ptr;
-    _subarray_broadcast_offsetrun *offsetruns = &d->offsetruns;
-
-    while (N > 0) {
-        loop_index = 0;
-        for (run = 0; run < run_count; ++run) {
-            offset = offsetruns[run].offset;
-            count = offsetruns[run].count;
-            dst_ptr = dst + loop_index*dst_subitemsize;
-            if (offset != -1) {
-                subtransfer(dst_ptr, dst_subitemsize,
-                            src + offset, src_subitemsize,
-                            count, src_subitemsize,
-                            subdata);
-            }
-            else {
-                memset(dst_ptr, 0, count*dst_subitemsize);
-            }
-            loop_index += count;
-        }
-
-        src += src_stride;
-        dst += dst_stride;
-        --N;
-    }
-}
-
-
-static void
-_strided_to_strided_subarray_broadcast_withrefs(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *data)
-{
-    _subarray_broadcast_data *d = (_subarray_broadcast_data *)data;
-    PyArray_StridedUnaryOp *subtransfer = d->stransfer;
-    NpyAuxData *subdata = d->data;
-    PyArray_StridedUnaryOp *stransfer_decsrcref = d->stransfer_decsrcref;
-    NpyAuxData *data_decsrcref = d->data_decsrcref;
-    PyArray_StridedUnaryOp *stransfer_decdstref = d->stransfer_decdstref;
-    NpyAuxData *data_decdstref = d->data_decdstref;
-    npy_intp run, run_count = d->run_count,
-            src_subitemsize = d->src_itemsize,
-            dst_subitemsize = d->dst_itemsize,
-            src_subN = d->src_N;
-    npy_intp loop_index, offset, count;
-    char *dst_ptr;
-    _subarray_broadcast_offsetrun *offsetruns = &d->offsetruns;
-
-    while (N > 0) {
-        loop_index = 0;
-        for (run = 0; run < run_count; ++run) {
-            offset = offsetruns[run].offset;
-            count = offsetruns[run].count;
-            dst_ptr = dst + loop_index*dst_subitemsize;
-            if (offset != -1) {
-                subtransfer(dst_ptr, dst_subitemsize,
-                            src + offset, src_subitemsize,
-                            count, src_subitemsize,
-                            subdata);
-            }
-            else {
-                if (stransfer_decdstref != NULL) {
-                    stransfer_decdstref(NULL, 0, dst_ptr, dst_subitemsize,
-                                        count, dst_subitemsize,
-                                        data_decdstref);
-                }
-                memset(dst_ptr, 0, count*dst_subitemsize);
-            }
-            loop_index += count;
-        }
-
-        if (stransfer_decsrcref != NULL) {
-            stransfer_decsrcref(NULL, 0, src, src_subitemsize,
-                                    src_subN, src_subitemsize,
-                                    data_decsrcref);
-        }
-
-        src += src_stride;
-        dst += dst_stride;
-        --N;
-    }
-}
-
-
-static int
-get_subarray_broadcast_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            npy_intp src_size, npy_intp dst_size,
-                            PyArray_Dims src_shape, PyArray_Dims dst_shape,
-                            int move_references,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    _subarray_broadcast_data *data;
-    npy_intp structsize, loop_index, run, run_size,
-             src_index, dst_index, i, ndim;
-    _subarray_broadcast_offsetrun *offsetruns;
-
-    structsize = sizeof(_subarray_broadcast_data) +
-                        dst_size*sizeof(_subarray_broadcast_offsetrun);
-
-    /* Allocate the data and populate it */
-    data = (_subarray_broadcast_data *)PyArray_malloc(structsize);
-    if (data == NULL) {
-        PyErr_NoMemory();
-        return NPY_FAIL;
-    }
-
-    /*
-     * move_references is set to 0, handled in the wrapping transfer fn,
-     * src_stride and dst_stride are set to contiguous, as N will always
-     * be 1 when it's called.
-     */
-    if (PyArray_GetDTypeTransferFunction(aligned,
-                    src_dtype->elsize, dst_dtype->elsize,
-                    src_dtype, dst_dtype,
-                    0,
-                    &data->stransfer, &data->data,
-                    out_needs_api) != NPY_SUCCEED) {
-        PyArray_free(data);
-        return NPY_FAIL;
-    }
-    data->base.free = &_subarray_broadcast_data_free;
-    data->base.clone = &_subarray_broadcast_data_clone;
-    data->src_N = src_size;
-    data->dst_N = dst_size;
-    data->src_itemsize = src_dtype->elsize;
-    data->dst_itemsize = dst_dtype->elsize;
-
-    /* If the src object will need a DECREF */
-    if (move_references && PyDataType_REFCHK(src_dtype)) {
-        if (PyArray_GetDTypeTransferFunction(aligned,
-                        src_dtype->elsize, 0,
-                        src_dtype, NULL,
-                        1,
-                        &data->stransfer_decsrcref,
-                        &data->data_decsrcref,
-                        out_needs_api) != NPY_SUCCEED) {
-            NPY_AUXDATA_FREE(data->data);
-            PyArray_free(data);
-            return NPY_FAIL;
-        }
-    }
-    else {
-        data->stransfer_decsrcref = NULL;
-        data->data_decsrcref = NULL;
-    }
-
-    /* If the dst object needs a DECREF to set it to NULL */
-    if (PyDataType_REFCHK(dst_dtype)) {
-        if (PyArray_GetDTypeTransferFunction(aligned,
-                        dst_dtype->elsize, 0,
-                        dst_dtype, NULL,
-                        1,
-                        &data->stransfer_decdstref,
-                        &data->data_decdstref,
-                        out_needs_api) != NPY_SUCCEED) {
-            NPY_AUXDATA_FREE(data->data);
-            NPY_AUXDATA_FREE(data->data_decsrcref);
-            PyArray_free(data);
-            return NPY_FAIL;
-        }
-    }
-    else {
-        data->stransfer_decdstref = NULL;
-        data->data_decdstref = NULL;
-    }
-
-    /* Calculate the broadcasting and set the offsets */
-    offsetruns = &data->offsetruns;
-    ndim = (src_shape.len > dst_shape.len) ? src_shape.len : dst_shape.len;
-    for (loop_index = 0; loop_index < dst_size; ++loop_index) {
-        npy_intp src_factor = 1;
-
-        dst_index = loop_index;
-        src_index = 0;
-        for (i = ndim-1; i >= 0; --i) {
-            npy_intp coord = 0, shape;
-
-            /* Get the dst coord of this index for dimension i */
-            if (i >= ndim - dst_shape.len) {
-                shape = dst_shape.ptr[i-(ndim-dst_shape.len)];
-                coord = dst_index % shape;
-                dst_index /= shape;
-            }
-
-            /* Translate it into a src coord and update src_index */
-            if (i >= ndim - src_shape.len) {
-                shape = src_shape.ptr[i-(ndim-src_shape.len)];
-                if (shape == 1) {
-                    coord = 0;
-                }
-                else {
-                    if (coord < shape) {
-                        src_index += src_factor*coord;
-                        src_factor *= shape;
-                    }
-                    else {
-                        /* Out of bounds, flag with -1 */
-                        src_index = -1;
-                        break;
-                    }
-                }
-            }
-        }
-        /* Set the offset */
-        if (src_index == -1) {
-            offsetruns[loop_index].offset = -1;
-        }
-        else {
-            offsetruns[loop_index].offset = src_index;
-        }
-    }
-
-    /* Run-length encode the result */
-    run = 0;
-    run_size = 1;
-    for (loop_index = 1; loop_index < dst_size; ++loop_index) {
-        if (offsetruns[run].offset == -1) {
-            /* Stop the run when there's a valid index again */
-            if (offsetruns[loop_index].offset != -1) {
-                offsetruns[run].count = run_size;
-                run++;
-                run_size = 1;
-                offsetruns[run].offset = offsetruns[loop_index].offset;
-            }
-            else {
-                run_size++;
-            }
-        }
-        else {
-            /* Stop the run when there's a valid index again */
-            if (offsetruns[loop_index].offset !=
-                            offsetruns[loop_index-1].offset + 1) {
-                offsetruns[run].count = run_size;
-                run++;
-                run_size = 1;
-                offsetruns[run].offset = offsetruns[loop_index].offset;
-            }
-            else {
-                run_size++;
-            }
-        }
-    }
-    offsetruns[run].count = run_size;
-    run++;
-    data->run_count = run;
-
-    /* Multiply all the offsets by the src item size */
-    while (run--) {
-        if (offsetruns[run].offset != -1) {
-            offsetruns[run].offset *= src_dtype->elsize;
-        }
-    }
-
-    if (data->stransfer_decsrcref == NULL &&
-                                data->stransfer_decdstref == NULL) {
-        *out_stransfer = &_strided_to_strided_subarray_broadcast;
-    }
-    else {
-        *out_stransfer = &_strided_to_strided_subarray_broadcast_withrefs;
-    }
-    *out_transferdata = (NpyAuxData *)data;
-
-    return NPY_SUCCEED;
-}
-
-/*
- * Handles subarray transfer.  To call this, at least one of the dtype's
- * subarrays must be non-NULL
- */
-static int
-get_subarray_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            int move_references,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    PyArray_Dims src_shape = {NULL, -1}, dst_shape = {NULL, -1};
-    npy_intp src_size = 1, dst_size = 1;
-
-    /* Get the subarray shapes and sizes */
-    if (PyDataType_HASSUBARRAY(src_dtype)) {
-       if (!(PyArray_IntpConverter(src_dtype->subarray->shape,
-                                            &src_shape))) {
-            PyErr_SetString(PyExc_ValueError,
-                    "invalid subarray shape");
-            return NPY_FAIL;
-        }
-        src_size = PyArray_MultiplyList(src_shape.ptr, src_shape.len);
-        src_dtype = src_dtype->subarray->base;
-    }
-    if (PyDataType_HASSUBARRAY(dst_dtype)) {
-       if (!(PyArray_IntpConverter(dst_dtype->subarray->shape,
-                                            &dst_shape))) {
-            PyDimMem_FREE(src_shape.ptr);
-            PyErr_SetString(PyExc_ValueError,
-                    "invalid subarray shape");
-            return NPY_FAIL;
-        }
-        dst_size = PyArray_MultiplyList(dst_shape.ptr, dst_shape.len);
-        dst_dtype = dst_dtype->subarray->base;
-    }
-
-    /*
-     * Just a straight one-element copy.
-     */
-    if (dst_size == 1 && src_size == 1) {
-        PyDimMem_FREE(src_shape.ptr);
-        PyDimMem_FREE(dst_shape.ptr);
-
-        return PyArray_GetDTypeTransferFunction(aligned,
-                src_stride, dst_stride,
-                src_dtype, dst_dtype,
-                move_references,
-                out_stransfer, out_transferdata,
-                out_needs_api);
-    }
-    /* Copy the src value to all the dst values */
-    else if (src_size == 1) {
-        PyDimMem_FREE(src_shape.ptr);
-        PyDimMem_FREE(dst_shape.ptr);
-
-        return get_one_to_n_transfer_function(aligned,
-                        src_stride, dst_stride,
-                        src_dtype, dst_dtype,
-                        move_references,
-                        dst_size,
-                        out_stransfer, out_transferdata,
-                        out_needs_api);
-    }
-    /* If the shapes match exactly, do an n to n copy */
-    else if (src_shape.len == dst_shape.len &&
-               PyArray_CompareLists(src_shape.ptr, dst_shape.ptr,
-                                                    src_shape.len)) {
-        PyDimMem_FREE(src_shape.ptr);
-        PyDimMem_FREE(dst_shape.ptr);
-
-        return get_n_to_n_transfer_function(aligned,
-                        src_stride, dst_stride,
-                        src_dtype, dst_dtype,
-                        move_references,
-                        src_size,
-                        out_stransfer, out_transferdata,
-                        out_needs_api);
-    }
-    /*
-     * Copy the subarray with broadcasting, truncating, and zero-padding
-     * as necessary.
-     */
-    else {
-        int ret = get_subarray_broadcast_transfer_function(aligned,
-                        src_stride, dst_stride,
-                        src_dtype, dst_dtype,
-                        src_size, dst_size,
-                        src_shape, dst_shape,
-                        move_references,
-                        out_stransfer, out_transferdata,
-                        out_needs_api);
-
-        PyDimMem_FREE(src_shape.ptr);
-        PyDimMem_FREE(dst_shape.ptr);
-        return ret;
-    }
-}
-
-/**************************** COPY FIELDS *******************************/
-typedef struct {
-    npy_intp src_offset, dst_offset, src_itemsize;
-    PyArray_StridedUnaryOp *stransfer;
-    NpyAuxData *data;
-} _single_field_transfer;
-
-typedef struct {
-    NpyAuxData base;
-    npy_intp field_count;
-
-    _single_field_transfer fields;
-} _field_transfer_data;
-
-/* transfer data free function */
-static void _field_transfer_data_free(NpyAuxData *data)
-{
-    _field_transfer_data *d = (_field_transfer_data *)data;
-    npy_intp i, field_count;
-    _single_field_transfer *fields;
-
-    field_count = d->field_count;
-    fields = &d->fields;
-
-    for (i = 0; i < field_count; ++i) {
-        NPY_AUXDATA_FREE(fields[i].data);
-    }
-    PyArray_free(d);
-}
-
-/* transfer data copy function */
-static NpyAuxData *_field_transfer_data_clone(NpyAuxData *data)
-{
-    _field_transfer_data *d = (_field_transfer_data *)data;
-    _field_transfer_data *newdata;
-    npy_intp i, field_count = d->field_count, structsize;
-    _single_field_transfer *fields, *newfields;
-
-    structsize = sizeof(_field_transfer_data) +
-                    field_count * sizeof(_single_field_transfer);
-
-    /* Allocate the data and populate it */
-    newdata = (_field_transfer_data *)PyArray_malloc(structsize);
-    if (newdata == NULL) {
-        return NULL;
-    }
-    memcpy(newdata, d, structsize);
-    /* Copy all the fields transfer data */
-    fields = &d->fields;
-    newfields = &newdata->fields;
-    for (i = 0; i < field_count; ++i) {
-        if (fields[i].data != NULL) {
-            newfields[i].data = NPY_AUXDATA_CLONE(fields[i].data);
-            if (newfields[i].data == NULL) {
-                for (i = i-1; i >= 0; --i) {
-                    NPY_AUXDATA_FREE(newfields[i].data);
-                }
-                PyArray_free(newdata);
-                return NULL;
-            }
-        }
-
-    }
-
-    return (NpyAuxData *)newdata;
-}
-
-static void
-_strided_to_strided_field_transfer(char *dst, npy_intp dst_stride,
-                        char *src, npy_intp src_stride,
-                        npy_intp N, npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *data)
-{
-    _field_transfer_data *d = (_field_transfer_data *)data;
-    npy_intp i, field_count = d->field_count;
-    _single_field_transfer *field;
-
-    /* Do the transfer a block at a time */
-    for (;;) {
-        field = &d->fields;
-        if (N > NPY_LOWLEVEL_BUFFER_BLOCKSIZE) {
-            for (i = 0; i < field_count; ++i, ++field) {
-                field->stransfer(dst + field->dst_offset, dst_stride,
-                                 src + field->src_offset, src_stride,
-                                 NPY_LOWLEVEL_BUFFER_BLOCKSIZE,
-                                 field->src_itemsize,
-                                 field->data);
-            }
-            N -= NPY_LOWLEVEL_BUFFER_BLOCKSIZE;
-            src += NPY_LOWLEVEL_BUFFER_BLOCKSIZE*src_stride;
-            dst += NPY_LOWLEVEL_BUFFER_BLOCKSIZE*dst_stride;
-        }
-        else {
-            for (i = 0; i < field_count; ++i, ++field) {
-                field->stransfer(dst + field->dst_offset, dst_stride,
-                                 src + field->src_offset, src_stride,
-                                 N,
-                                 field->src_itemsize,
-                                 field->data);
-            }
-            return;
-        }
-    }
-}
-
-/*
- * Handles fields transfer.  To call this, at least one of the dtypes
- * must have fields
- */
-static int
-get_fields_transfer_function(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            int move_references,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    PyObject *names, *key, *tup, *title;
-    PyArray_Descr *src_fld_dtype, *dst_fld_dtype;
-    npy_int i, names_size, field_count, structsize;
-    int src_offset, dst_offset;
-    _field_transfer_data *data;
-    _single_field_transfer *fields;
-
-    /* Copy the src value to all the fields of dst */
-    if (!PyDataType_HASFIELDS(src_dtype)) {
-        names = dst_dtype->names;
-        names_size = PyTuple_GET_SIZE(dst_dtype->names);
-
-        field_count = names_size;
-        structsize = sizeof(_field_transfer_data) +
-                        (field_count + 1) * sizeof(_single_field_transfer);
-        /* Allocate the data and populate it */
-        data = (_field_transfer_data *)PyArray_malloc(structsize);
-        if (data == NULL) {
-            PyErr_NoMemory();
-            return NPY_FAIL;
-        }
-        data->base.free = &_field_transfer_data_free;
-        data->base.clone = &_field_transfer_data_clone;
-        fields = &data->fields;
-
-        for (i = 0; i < names_size; ++i) {
-            key = PyTuple_GET_ITEM(names, i);
-            tup = PyDict_GetItem(dst_dtype->fields, key);
-            if (!PyArg_ParseTuple(tup, "Oi|O", &dst_fld_dtype,
-                                                    &dst_offset, &title)) {
-                PyArray_free(data);
-                return NPY_FAIL;
-            }
-            if (PyArray_GetDTypeTransferFunction(0,
-                                    src_stride, dst_stride,
-                                    src_dtype, dst_fld_dtype,
-                                    0,
-                                    &fields[i].stransfer,
-                                    &fields[i].data,
-                                    out_needs_api) != NPY_SUCCEED) {
-                for (i = i-1; i >= 0; --i) {
-                    NPY_AUXDATA_FREE(fields[i].data);
-                }
-                PyArray_free(data);
-                return NPY_FAIL;
-            }
-            fields[i].src_offset = 0;
-            fields[i].dst_offset = dst_offset;
-            fields[i].src_itemsize = src_dtype->elsize;
-        }
-
-        /*
-         * If the references should be removed from src, add
-         * another transfer function to do that.
-         */
-        if (move_references && PyDataType_REFCHK(src_dtype)) {
-            if (get_decsrcref_transfer_function(0,
-                                    src_stride,
-                                    src_dtype,
-                                    &fields[field_count].stransfer,
-                                    &fields[field_count].data,
-                                    out_needs_api) != NPY_SUCCEED) {
-                for (i = 0; i < field_count; ++i) {
-                    NPY_AUXDATA_FREE(fields[i].data);
-                }
-                PyArray_free(data);
-                return NPY_FAIL;
-            }
-            fields[field_count].src_offset = 0;
-            fields[field_count].dst_offset = 0;
-            fields[field_count].src_itemsize = src_dtype->elsize;
-            field_count++;
-        }
-        data->field_count = field_count;
-
-        *out_stransfer = &_strided_to_strided_field_transfer;
-        *out_transferdata = (NpyAuxData *)data;
-
-        return NPY_SUCCEED;
-    }
-    /* Copy the value of the first field to dst */
-    else if (!PyDataType_HASFIELDS(dst_dtype)) {
-        names = src_dtype->names;
-        names_size = PyTuple_GET_SIZE(src_dtype->names);
-
-        /*
-         * If DECREF is needed on source fields, may need
-         * to process all the fields
-         */
-        if (move_references && PyDataType_REFCHK(src_dtype)) {
-            field_count = names_size + 1;
-        }
-        else {
-            field_count = 1;
-        }
-        structsize = sizeof(_field_transfer_data) +
-                        field_count * sizeof(_single_field_transfer);
-        /* Allocate the data and populate it */
-        data = (_field_transfer_data *)PyArray_malloc(structsize);
-        if (data == NULL) {
-            PyErr_NoMemory();
-            return NPY_FAIL;
-        }
-        data->base.free = &_field_transfer_data_free;
-        data->base.clone = &_field_transfer_data_clone;
-        fields = &data->fields;
-
-        key = PyTuple_GET_ITEM(names, 0);
-        tup = PyDict_GetItem(src_dtype->fields, key);
-        if (!PyArg_ParseTuple(tup, "Oi|O", &src_fld_dtype,
-                                                &src_offset, &title)) {
-            PyArray_free(data);
-            return NPY_FAIL;
-        }
-        field_count = 0;
-        /*
-         * Special case bool type, the existence of fields implies True
-         *
-         * TODO: Perhaps a better behavior would be to combine all the
-         *       input fields with an OR?  The same would apply to subarrays.
-         */
-        if (dst_dtype->type_num == NPY_BOOL) {
-            if (get_bool_setdstone_transfer_function(dst_stride,
-                                    &fields[field_count].stransfer,
-                                    &fields[field_count].data,
-                                    out_needs_api) != NPY_SUCCEED) {
-                PyArray_free(data);
-                return NPY_FAIL;
-            }
-            fields[field_count].src_offset = 0;
-            fields[field_count].dst_offset = 0;
-            fields[field_count].src_itemsize = 0;
-            field_count++;
-
-            /* If the src field has references, may need to clear them */
-            if (move_references && PyDataType_REFCHK(src_fld_dtype)) {
-                if (get_decsrcref_transfer_function(0,
-                            src_stride,
-                            src_fld_dtype,
-                            &fields[field_count].stransfer,
-                            &fields[field_count].data,
-                            out_needs_api) != NPY_SUCCEED) {
-                    NPY_AUXDATA_FREE(fields[0].data);
-                    PyArray_free(data);
-                    return NPY_FAIL;
-                }
-                fields[field_count].src_offset = src_offset;
-                fields[field_count].dst_offset = 0;
-                fields[field_count].src_itemsize = src_fld_dtype->elsize;
-                field_count++;
-            }
-        }
-        /* Transfer the first field to the output */
-        else {
-            if (PyArray_GetDTypeTransferFunction(0,
-                                    src_stride, dst_stride,
-                                    src_fld_dtype, dst_dtype,
-                                    move_references,
-                                    &fields[field_count].stransfer,
-                                    &fields[field_count].data,
-                                    out_needs_api) != NPY_SUCCEED) {
-                PyArray_free(data);
-                return NPY_FAIL;
-            }
-            fields[field_count].src_offset = src_offset;
-            fields[field_count].dst_offset = 0;
-            fields[field_count].src_itemsize = src_fld_dtype->elsize;
-            field_count++;
-        }
-
-        /*
-         * If the references should be removed from src, add
-         * more transfer functions to decrement the references
-         * for all the other fields.
-         */
-        if (move_references && PyDataType_REFCHK(src_dtype)) {
-            for (i = 1; i < names_size; ++i) {
-                key = PyTuple_GET_ITEM(names, i);
-                tup = PyDict_GetItem(src_dtype->fields, key);
-                if (!PyArg_ParseTuple(tup, "Oi|O", &src_fld_dtype,
-                                                    &src_offset, &title)) {
-                    return NPY_FAIL;
-                }
-                if (PyDataType_REFCHK(src_fld_dtype)) {
-                    if (get_decsrcref_transfer_function(0,
-                                src_stride,
-                                src_fld_dtype,
-                                &fields[field_count].stransfer,
-                                &fields[field_count].data,
-                                out_needs_api) != NPY_SUCCEED) {
-                        for (i = field_count-1; i >= 0; --i) {
-                            NPY_AUXDATA_FREE(fields[i].data);
-                        }
-                        PyArray_free(data);
-                        return NPY_FAIL;
-                    }
-                    fields[field_count].src_offset = src_offset;
-                    fields[field_count].dst_offset = 0;
-                    fields[field_count].src_itemsize = src_fld_dtype->elsize;
-                    field_count++;
-                }
-            }
-        }
-
-        data->field_count = field_count;
-
-        *out_stransfer = &_strided_to_strided_field_transfer;
-        *out_transferdata = (NpyAuxData *)data;
-
-        return NPY_SUCCEED;
-    }
-    /* Match up the fields to copy */
-    else {
-        /* Keeps track of the names we already used */
-        PyObject *used_names_dict = NULL;
-
-        names = dst_dtype->names;
-        names_size = PyTuple_GET_SIZE(dst_dtype->names);
-
-        /*
-         * If DECREF is needed on source fields, will need
-         * to also go through its fields.
-         */
-        if (move_references && PyDataType_REFCHK(src_dtype)) {
-            field_count = names_size + PyTuple_GET_SIZE(src_dtype->names);
-            used_names_dict = PyDict_New();
-            if (used_names_dict == NULL) {
-                return NPY_FAIL;
-            }
-        }
-        else {
-            field_count = names_size;
-        }
-        structsize = sizeof(_field_transfer_data) +
-                        field_count * sizeof(_single_field_transfer);
-        /* Allocate the data and populate it */
-        data = (_field_transfer_data *)PyArray_malloc(structsize);
-        if (data == NULL) {
-            PyErr_NoMemory();
-            Py_XDECREF(used_names_dict);
-            return NPY_FAIL;
-        }
-        data->base.free = &_field_transfer_data_free;
-        data->base.clone = &_field_transfer_data_clone;
-        fields = &data->fields;
-
-        for (i = 0; i < names_size; ++i) {
-            key = PyTuple_GET_ITEM(names, i);
-            tup = PyDict_GetItem(dst_dtype->fields, key);
-            if (!PyArg_ParseTuple(tup, "Oi|O", &dst_fld_dtype,
-                                                    &dst_offset, &title)) {
-                for (i = i-1; i >= 0; --i) {
-                    NPY_AUXDATA_FREE(fields[i].data);
-                }
-                PyArray_free(data);
-                Py_XDECREF(used_names_dict);
-                return NPY_FAIL;
-            }
-            tup = PyDict_GetItem(src_dtype->fields, key);
-            if (tup != NULL) {
-                if (!PyArg_ParseTuple(tup, "Oi|O", &src_fld_dtype,
-                                                        &src_offset, &title)) {
-                    for (i = i-1; i >= 0; --i) {
-                        NPY_AUXDATA_FREE(fields[i].data);
-                    }
-                    PyArray_free(data);
-                    Py_XDECREF(used_names_dict);
-                    return NPY_FAIL;
-                }
-                if (PyArray_GetDTypeTransferFunction(0,
-                                        src_stride, dst_stride,
-                                        src_fld_dtype, dst_fld_dtype,
-                                        move_references,
-                                        &fields[i].stransfer,
-                                        &fields[i].data,
-                                        out_needs_api) != NPY_SUCCEED) {
-                    for (i = i-1; i >= 0; --i) {
-                        NPY_AUXDATA_FREE(fields[i].data);
-                    }
-                    PyArray_free(data);
-                    Py_XDECREF(used_names_dict);
-                    return NPY_FAIL;
-                }
-                fields[i].src_offset = src_offset;
-                fields[i].dst_offset = dst_offset;
-                fields[i].src_itemsize = src_fld_dtype->elsize;
-
-                if (used_names_dict != NULL) {
-                    PyDict_SetItem(used_names_dict, key, Py_True);
-                }
-            }
-            else {
-                if (get_setdstzero_transfer_function(0,
-                                            dst_stride,
-                                            dst_fld_dtype,
-                                            &fields[i].stransfer,
-                                            &fields[i].data,
-                                            out_needs_api) != NPY_SUCCEED) {
-                    for (i = i-1; i >= 0; --i) {
-                        NPY_AUXDATA_FREE(fields[i].data);
-                    }
-                    PyArray_free(data);
-                    Py_XDECREF(used_names_dict);
-                    return NPY_FAIL;
-                }
-                fields[i].src_offset = 0;
-                fields[i].dst_offset = dst_offset;
-                fields[i].src_itemsize = 0;
-            }
-        }
-
-        if (move_references && PyDataType_REFCHK(src_dtype)) {
-            /* Use field_count to track additional functions added */
-            field_count = names_size;
-
-            names = src_dtype->names;
-            names_size = PyTuple_GET_SIZE(src_dtype->names);
-            for (i = 0; i < names_size; ++i) {
-                key = PyTuple_GET_ITEM(names, i);
-                if (PyDict_GetItem(used_names_dict, key) == NULL) {
-                    tup = PyDict_GetItem(src_dtype->fields, key);
-                    if (!PyArg_ParseTuple(tup, "Oi|O", &src_fld_dtype,
-                                                    &src_offset, &title)) {
-                        for (i = field_count-1; i >= 0; --i) {
-                            NPY_AUXDATA_FREE(fields[i].data);
-                        }
-                        PyArray_free(data);
-                        Py_XDECREF(used_names_dict);
-                        return NPY_FAIL;
-                    }
-                    if (PyDataType_REFCHK(src_fld_dtype)) {
-                        if (get_decsrcref_transfer_function(0,
-                                    src_stride,
-                                    src_fld_dtype,
-                                    &fields[field_count].stransfer,
-                                    &fields[field_count].data,
-                                    out_needs_api) != NPY_SUCCEED) {
-                            for (i = field_count-1; i >= 0; --i) {
-                                NPY_AUXDATA_FREE(fields[i].data);
-                            }
-                            PyArray_free(data);
-                            return NPY_FAIL;
-                        }
-                        fields[field_count].src_offset = src_offset;
-                        fields[field_count].dst_offset = 0;
-                        fields[field_count].src_itemsize =
-                                                src_fld_dtype->elsize;
-                        field_count++;
-                    }
-                }
-            }
-        }
-
-        Py_XDECREF(used_names_dict);
-
-        data->field_count = field_count;
-
-        *out_stransfer = &_strided_to_strided_field_transfer;
-        *out_transferdata = (NpyAuxData *)data;
-
-        return NPY_SUCCEED;
-    }
-}
-
-static int
-get_decsrcref_fields_transfer_function(int aligned,
-                            npy_intp src_stride,
-                            PyArray_Descr *src_dtype,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    PyObject *names, *key, *tup, *title;
-    PyArray_Descr *src_fld_dtype;
-    npy_int i, names_size, field_count, structsize;
-    int src_offset;
-    _field_transfer_data *data;
-    _single_field_transfer *fields;
-
-    names = src_dtype->names;
-    names_size = PyTuple_GET_SIZE(src_dtype->names);
-
-    field_count = names_size;
-    structsize = sizeof(_field_transfer_data) +
-                    field_count * sizeof(_single_field_transfer);
-    /* Allocate the data and populate it */
-    data = (_field_transfer_data *)PyArray_malloc(structsize);
-    if (data == NULL) {
-        PyErr_NoMemory();
-        return NPY_FAIL;
-    }
-    data->base.free = &_field_transfer_data_free;
-    data->base.clone = &_field_transfer_data_clone;
-    fields = &data->fields;
-
-    field_count = 0;
-    for (i = 0; i < names_size; ++i) {
-        key = PyTuple_GET_ITEM(names, i);
-        tup = PyDict_GetItem(src_dtype->fields, key);
-        if (!PyArg_ParseTuple(tup, "Oi|O", &src_fld_dtype,
-                                                &src_offset, &title)) {
-            PyArray_free(data);
-            return NPY_FAIL;
-        }
-        if (PyDataType_REFCHK(src_fld_dtype)) {
-            if (out_needs_api) {
-                *out_needs_api = 1;
-            }
-            if (get_decsrcref_transfer_function(0,
-                                    src_stride,
-                                    src_fld_dtype,
-                                    &fields[field_count].stransfer,
-                                    &fields[field_count].data,
-                                    out_needs_api) != NPY_SUCCEED) {
-                for (i = field_count-1; i >= 0; --i) {
-                    NPY_AUXDATA_FREE(fields[i].data);
-                }
-                PyArray_free(data);
-                return NPY_FAIL;
-            }
-            fields[field_count].src_offset = src_offset;
-            fields[field_count].dst_offset = 0;
-            fields[field_count].src_itemsize = src_dtype->elsize;
-            field_count++;
-        }
-    }
-
-    data->field_count = field_count;
-
-    *out_stransfer = &_strided_to_strided_field_transfer;
-    *out_transferdata = (NpyAuxData *)data;
-
-    return NPY_SUCCEED;
-}
-
-static int
-get_setdestzero_fields_transfer_function(int aligned,
-                            npy_intp dst_stride,
-                            PyArray_Descr *dst_dtype,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    PyObject *names, *key, *tup, *title;
-    PyArray_Descr *dst_fld_dtype;
-    npy_int i, names_size, field_count, structsize;
-    int dst_offset;
-    _field_transfer_data *data;
-    _single_field_transfer *fields;
-
-    names = dst_dtype->names;
-    names_size = PyTuple_GET_SIZE(dst_dtype->names);
-
-    field_count = names_size;
-    structsize = sizeof(_field_transfer_data) +
-                    field_count * sizeof(_single_field_transfer);
-    /* Allocate the data and populate it */
-    data = (_field_transfer_data *)PyArray_malloc(structsize);
-    if (data == NULL) {
-        PyErr_NoMemory();
-        return NPY_FAIL;
-    }
-    data->base.free = &_field_transfer_data_free;
-    data->base.clone = &_field_transfer_data_clone;
-    fields = &data->fields;
-
-    for (i = 0; i < names_size; ++i) {
-        key = PyTuple_GET_ITEM(names, i);
-        tup = PyDict_GetItem(dst_dtype->fields, key);
-        if (!PyArg_ParseTuple(tup, "Oi|O", &dst_fld_dtype,
-                                                &dst_offset, &title)) {
-            PyArray_free(data);
-            return NPY_FAIL;
-        }
-        if (get_setdstzero_transfer_function(0,
-                                dst_stride,
-                                dst_fld_dtype,
-                                &fields[i].stransfer,
-                                &fields[i].data,
-                                out_needs_api) != NPY_SUCCEED) {
-            for (i = i-1; i >= 0; --i) {
-                NPY_AUXDATA_FREE(fields[i].data);
-            }
-            PyArray_free(data);
-            return NPY_FAIL;
-        }
-        fields[i].src_offset = 0;
-        fields[i].dst_offset = dst_offset;
-        fields[i].src_itemsize = 0;
-    }
-
-    data->field_count = field_count;
-
-    *out_stransfer = &_strided_to_strided_field_transfer;
-    *out_transferdata = (NpyAuxData *)data;
-
-    return NPY_SUCCEED;
-}
-
-/************************* MASKED TRANSFER WRAPPER *************************/
-
-typedef struct {
-    NpyAuxData base;
-    /* The transfer function being wrapped */
-    PyArray_StridedUnaryOp *stransfer;
-    NpyAuxData *transferdata;
-
-    /* The src decref function if necessary */
-    PyArray_StridedUnaryOp *decsrcref_stransfer;
-    NpyAuxData *decsrcref_transferdata;
-} _masked_wrapper_transfer_data;
-
-/* transfer data free function */
-static void _masked_wrapper_transfer_data_free(NpyAuxData *data)
-{
-    _masked_wrapper_transfer_data *d = (_masked_wrapper_transfer_data *)data;
-    NPY_AUXDATA_FREE(d->transferdata);
-    NPY_AUXDATA_FREE(d->decsrcref_transferdata);
-    PyArray_free(data);
-}
-
-/* transfer data copy function */
-static NpyAuxData *_masked_wrapper_transfer_data_clone(NpyAuxData *data)
-{
-    _masked_wrapper_transfer_data *d = (_masked_wrapper_transfer_data *)data;
-    _masked_wrapper_transfer_data *newdata;
-
-    /* Allocate the data and populate it */
-    newdata = (_masked_wrapper_transfer_data *)PyArray_malloc(
-                                    sizeof(_masked_wrapper_transfer_data));
-    if (newdata == NULL) {
-        return NULL;
-    }
-    memcpy(newdata, d, sizeof(_masked_wrapper_transfer_data));
-
-    /* Clone all the owned auxdata as well */
-    if (newdata->transferdata != NULL) {
-        newdata->transferdata = NPY_AUXDATA_CLONE(newdata->transferdata);
-        if (newdata->transferdata == NULL) {
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-    if (newdata->decsrcref_transferdata != NULL) {
-        newdata->decsrcref_transferdata =
-                        NPY_AUXDATA_CLONE(newdata->decsrcref_transferdata);
-        if (newdata->decsrcref_transferdata == NULL) {
-            NPY_AUXDATA_FREE(newdata->transferdata);
-            PyArray_free(newdata);
-            return NULL;
-        }
-    }
-
-    return (NpyAuxData *)newdata;
-}
-
-static void _strided_masked_wrapper_decsrcref_transfer_function(
-                                    char *dst, npy_intp dst_stride,
-                                    char *src, npy_intp src_stride,
-                                    npy_bool *mask, npy_intp mask_stride,
-                                    npy_intp N, npy_intp src_itemsize,
-                                    NpyAuxData *transferdata)
-{
-    _masked_wrapper_transfer_data *d =
-                        (_masked_wrapper_transfer_data *)transferdata;
-    npy_intp subloopsize;
-    PyArray_StridedUnaryOp *unmasked_stransfer, *decsrcref_stransfer;
-    NpyAuxData *unmasked_transferdata, *decsrcref_transferdata;
-
-    unmasked_stransfer = d->stransfer;
-    unmasked_transferdata = d->transferdata;
-    decsrcref_stransfer = d->decsrcref_stransfer;
-    decsrcref_transferdata = d->decsrcref_transferdata;
-
-    while (N > 0) {
-        /* Skip masked values, still calling decsrcref for move_references */
-        mask = (npy_bool*)npy_memchr((char *)mask, 0, mask_stride, N,
-                                     &subloopsize, 1);
-        decsrcref_stransfer(NULL, 0, src, src_stride,
-                            subloopsize, src_itemsize, decsrcref_transferdata);
-        dst += subloopsize * dst_stride;
-        src += subloopsize * src_stride;
-        N -= subloopsize;
-        /* Process unmasked values */
-        mask = (npy_bool*)npy_memchr((char *)mask, 0, mask_stride, N,
-                                     &subloopsize, 0);
-        unmasked_stransfer(dst, dst_stride, src, src_stride,
-                            subloopsize, src_itemsize, unmasked_transferdata);
-        dst += subloopsize * dst_stride;
-        src += subloopsize * src_stride;
-        N -= subloopsize;
-    }
-}
-
-static void _strided_masked_wrapper_transfer_function(
-                                    char *dst, npy_intp dst_stride,
-                                    char *src, npy_intp src_stride,
-                                    npy_bool *mask, npy_intp mask_stride,
-                                    npy_intp N, npy_intp src_itemsize,
-                                    NpyAuxData *transferdata)
-{
-
-    _masked_wrapper_transfer_data *d =
-                            (_masked_wrapper_transfer_data *)transferdata;
-    npy_intp subloopsize;
-    PyArray_StridedUnaryOp *unmasked_stransfer;
-    NpyAuxData *unmasked_transferdata;
-
-    unmasked_stransfer = d->stransfer;
-    unmasked_transferdata = d->transferdata;
-
-    while (N > 0) {
-        /* Skip masked values */
-        mask = (npy_bool*)npy_memchr((char *)mask, 0, mask_stride, N,
-                                     &subloopsize, 1);
-        dst += subloopsize * dst_stride;
-        src += subloopsize * src_stride;
-        N -= subloopsize;
-        /* Process unmasked values */
-        mask = (npy_bool*)npy_memchr((char *)mask, 0, mask_stride, N,
-                                     &subloopsize, 0);
-        unmasked_stransfer(dst, dst_stride, src, src_stride,
-                            subloopsize, src_itemsize, unmasked_transferdata);
-        dst += subloopsize * dst_stride;
-        src += subloopsize * src_stride;
-        N -= subloopsize;
-    }
-}
-
-
-/************************* DEST BOOL SETONE *******************************/
-
-static void
-_null_to_strided_set_bool_one(char *dst,
-                        npy_intp dst_stride,
-                        char *NPY_UNUSED(src), npy_intp NPY_UNUSED(src_stride),
-                        npy_intp N, npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *NPY_UNUSED(data))
-{
-    /* bool type is one byte, so can just use the char */
-
-    while (N > 0) {
-        *dst = 1;
-
-        dst += dst_stride;
-        --N;
-    }
-}
-
-static void
-_null_to_contig_set_bool_one(char *dst,
-                        npy_intp NPY_UNUSED(dst_stride),
-                        char *NPY_UNUSED(src), npy_intp NPY_UNUSED(src_stride),
-                        npy_intp N, npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *NPY_UNUSED(data))
-{
-    /* bool type is one byte, so can just use the char */
-
-    memset(dst, 1, N);
-}
-
-/* Only for the bool type, sets the destination to 1 */
-NPY_NO_EXPORT int
-get_bool_setdstone_transfer_function(npy_intp dst_stride,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *NPY_UNUSED(out_needs_api))
-{
-    if (dst_stride == 1) {
-        *out_stransfer = &_null_to_contig_set_bool_one;
-    }
-    else {
-        *out_stransfer = &_null_to_strided_set_bool_one;
-    }
-    *out_transferdata = NULL;
-
-    return NPY_SUCCEED;
-}
-
-/*************************** DEST SETZERO *******************************/
-
-/* Sets dest to zero */
-typedef struct {
-    NpyAuxData base;
-    npy_intp dst_itemsize;
-} _dst_memset_zero_data;
-
-/* zero-padded data copy function */
-static NpyAuxData *_dst_memset_zero_data_clone(NpyAuxData *data)
-{
-    _dst_memset_zero_data *newdata =
-            (_dst_memset_zero_data *)PyArray_malloc(
-                                    sizeof(_dst_memset_zero_data));
-    if (newdata == NULL) {
-        return NULL;
-    }
-
-    memcpy(newdata, data, sizeof(_dst_memset_zero_data));
-
-    return (NpyAuxData *)newdata;
-}
-
-static void
-_null_to_strided_memset_zero(char *dst,
-                        npy_intp dst_stride,
-                        char *NPY_UNUSED(src), npy_intp NPY_UNUSED(src_stride),
-                        npy_intp N, npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *data)
-{
-    _dst_memset_zero_data *d = (_dst_memset_zero_data *)data;
-    npy_intp dst_itemsize = d->dst_itemsize;
-
-    while (N > 0) {
-        memset(dst, 0, dst_itemsize);
-        dst += dst_stride;
-        --N;
-    }
-}
-
-static void
-_null_to_contig_memset_zero(char *dst,
-                        npy_intp dst_stride,
-                        char *NPY_UNUSED(src), npy_intp NPY_UNUSED(src_stride),
-                        npy_intp N, npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *data)
-{
-    _dst_memset_zero_data *d = (_dst_memset_zero_data *)data;
-    npy_intp dst_itemsize = d->dst_itemsize;
-
-    memset(dst, 0, N*dst_itemsize);
-}
-
-static void
-_null_to_strided_reference_setzero(char *dst,
-                        npy_intp dst_stride,
-                        char *NPY_UNUSED(src), npy_intp NPY_UNUSED(src_stride),
-                        npy_intp N, npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *NPY_UNUSED(data))
-{
-    PyObject *dst_ref = NULL;
-
-    while (N > 0) {
-        NPY_COPY_PYOBJECT_PTR(&dst_ref, dst);
-
-        /* Release the reference in dst */
-        NPY_DT_DBG_REFTRACE("dec dest ref (to set zero)", dst_ref);
-        Py_XDECREF(dst_ref);
-
-        /* Set it to zero */
-        dst_ref = NULL;
-        NPY_COPY_PYOBJECT_PTR(dst, &dst_ref);
-
-        dst += dst_stride;
-        --N;
-    }
-}
-
-NPY_NO_EXPORT int
-get_setdstzero_transfer_function(int aligned,
-                            npy_intp dst_stride,
-                            PyArray_Descr *dst_dtype,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    _dst_memset_zero_data *data;
-
-    /* If there are no references, just set the whole thing to zero */
-    if (!PyDataType_REFCHK(dst_dtype)) {
-        data = (_dst_memset_zero_data *)
-                        PyArray_malloc(sizeof(_dst_memset_zero_data));
-        if (data == NULL) {
-            PyErr_NoMemory();
-            return NPY_FAIL;
-        }
-
-        data->base.free = (NpyAuxData_FreeFunc *)(&PyArray_free);
-        data->base.clone = &_dst_memset_zero_data_clone;
-        data->dst_itemsize = dst_dtype->elsize;
-
-        if (dst_stride == data->dst_itemsize) {
-            *out_stransfer = &_null_to_contig_memset_zero;
-        }
-        else {
-            *out_stransfer = &_null_to_strided_memset_zero;
-        }
-        *out_transferdata = (NpyAuxData *)data;
-    }
-    /* If it's exactly one reference, use the decref function */
-    else if (dst_dtype->type_num == NPY_OBJECT) {
-        if (out_needs_api) {
-            *out_needs_api = 1;
-        }
-
-        *out_stransfer = &_null_to_strided_reference_setzero;
-        *out_transferdata = NULL;
-    }
-    /* If there are subarrays, need to wrap it */
-    else if (PyDataType_HASSUBARRAY(dst_dtype)) {
-        PyArray_Dims dst_shape = {NULL, -1};
-        npy_intp dst_size = 1;
-        PyArray_StridedUnaryOp *contig_stransfer;
-        NpyAuxData *contig_data;
-
-        if (out_needs_api) {
-            *out_needs_api = 1;
-        }
-
-        if (!(PyArray_IntpConverter(dst_dtype->subarray->shape,
-                                            &dst_shape))) {
-            PyErr_SetString(PyExc_ValueError,
-                    "invalid subarray shape");
-            return NPY_FAIL;
-        }
-        dst_size = PyArray_MultiplyList(dst_shape.ptr, dst_shape.len);
-        PyDimMem_FREE(dst_shape.ptr);
-
-        /* Get a function for contiguous dst of the subarray type */
-        if (get_setdstzero_transfer_function(aligned,
-                                dst_dtype->subarray->base->elsize,
-                                dst_dtype->subarray->base,
-                                &contig_stransfer, &contig_data,
-                                out_needs_api) != NPY_SUCCEED) {
-            return NPY_FAIL;
-        }
-
-        if (wrap_transfer_function_n_to_n(contig_stransfer, contig_data,
-                            0, dst_stride,
-                            0, dst_dtype->subarray->base->elsize,
-                            dst_size,
-                            out_stransfer, out_transferdata) != NPY_SUCCEED) {
-            NPY_AUXDATA_FREE(contig_data);
-            return NPY_FAIL;
-        }
-    }
-    /* If there are fields, need to do each field */
-    else if (PyDataType_HASFIELDS(dst_dtype)) {
-        if (out_needs_api) {
-            *out_needs_api = 1;
-        }
-
-        return get_setdestzero_fields_transfer_function(aligned,
-                            dst_stride, dst_dtype,
-                            out_stransfer,
-                            out_transferdata,
-                            out_needs_api);
-    }
-
-    return NPY_SUCCEED;
-}
-
-static void
-_dec_src_ref_nop(char *NPY_UNUSED(dst),
-                        npy_intp NPY_UNUSED(dst_stride),
-                        char *NPY_UNUSED(src), npy_intp NPY_UNUSED(src_stride),
-                        npy_intp NPY_UNUSED(N),
-                        npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *NPY_UNUSED(data))
-{
-    /* NOP */
-}
-
-static void
-_strided_to_null_dec_src_ref_reference(char *NPY_UNUSED(dst),
-                        npy_intp NPY_UNUSED(dst_stride),
-                        char *src, npy_intp src_stride,
-                        npy_intp N,
-                        npy_intp NPY_UNUSED(src_itemsize),
-                        NpyAuxData *NPY_UNUSED(data))
-{
-    PyObject *src_ref = NULL;
-    while (N > 0) {
-        NPY_COPY_PYOBJECT_PTR(&src_ref, src);
-
-        /* Release the reference in src */
-        NPY_DT_DBG_REFTRACE("dec src ref (null dst)", src_ref);
-        Py_XDECREF(src_ref);
-
-        src += src_stride;
-        --N;
-    }
-}
-
-
-NPY_NO_EXPORT int
-get_decsrcref_transfer_function(int aligned,
-                            npy_intp src_stride,
-                            PyArray_Descr *src_dtype,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    /* If there are no references, it's a nop */
-    if (!PyDataType_REFCHK(src_dtype)) {
-        *out_stransfer = &_dec_src_ref_nop;
-        *out_transferdata = NULL;
-
-        return NPY_SUCCEED;
-    }
-    /* If it's a single reference, it's one decref */
-    else if (src_dtype->type_num == NPY_OBJECT) {
-        if (out_needs_api) {
-            *out_needs_api = 1;
-        }
-
-        *out_stransfer = &_strided_to_null_dec_src_ref_reference;
-        *out_transferdata = NULL;
-
-        return NPY_SUCCEED;
-    }
-    /* If there are subarrays, need to wrap it */
-    else if (PyDataType_HASSUBARRAY(src_dtype)) {
-        PyArray_Dims src_shape = {NULL, -1};
-        npy_intp src_size = 1;
-        PyArray_StridedUnaryOp *stransfer;
-        NpyAuxData *data;
-
-        if (out_needs_api) {
-            *out_needs_api = 1;
-        }
-
-        if (!(PyArray_IntpConverter(src_dtype->subarray->shape,
-                                            &src_shape))) {
-            PyErr_SetString(PyExc_ValueError,
-                    "invalid subarray shape");
-            return NPY_FAIL;
-        }
-        src_size = PyArray_MultiplyList(src_shape.ptr, src_shape.len);
-        PyDimMem_FREE(src_shape.ptr);
-
-        /* Get a function for contiguous src of the subarray type */
-        if (get_decsrcref_transfer_function(aligned,
-                                src_dtype->subarray->base->elsize,
-                                src_dtype->subarray->base,
-                                &stransfer, &data,
-                                out_needs_api) != NPY_SUCCEED) {
-            return NPY_FAIL;
-        }
-
-        if (wrap_transfer_function_n_to_n(stransfer, data,
-                                src_stride, 0,
-                                src_dtype->subarray->base->elsize, 0,
-                                src_size,
-                                out_stransfer, out_transferdata) != NPY_SUCCEED) {
-            NPY_AUXDATA_FREE(data);
-            return NPY_FAIL;
-        }
-
-        return NPY_SUCCEED;
-    }
-    /* If there are fields, need to do each field */
-    else {
-        if (out_needs_api) {
-            *out_needs_api = 1;
-        }
-
-        return get_decsrcref_fields_transfer_function(aligned,
-                            src_stride, src_dtype,
-                            out_stransfer,
-                            out_transferdata,
-                            out_needs_api);
-    }
-}
-
-/********************* DTYPE COPY SWAP FUNCTION ***********************/
-
-NPY_NO_EXPORT int
-PyArray_GetDTypeCopySwapFn(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *dtype,
-                            PyArray_StridedUnaryOp **outstransfer,
-                            NpyAuxData **outtransferdata)
-{
-    npy_intp itemsize = dtype->elsize;
-
-    /* If it's a custom data type, wrap its copy swap function */
-    if (dtype->type_num >= NPY_NTYPES) {
-        *outstransfer = NULL;
-        wrap_copy_swap_function(aligned,
-                            src_stride, dst_stride,
-                            dtype,
-                            !PyArray_ISNBO(dtype->byteorder),
-                            outstransfer, outtransferdata);
-    }
-    /* A straight copy */
-    else if (itemsize == 1 || PyArray_ISNBO(dtype->byteorder)) {
-        *outstransfer = PyArray_GetStridedCopyFn(aligned,
-                                    src_stride, dst_stride,
-                                    itemsize);
-        *outtransferdata = NULL;
-    }
-    /* If it's not complex, one swap */
-    else if(dtype->kind != 'c') {
-        *outstransfer = PyArray_GetStridedCopySwapFn(aligned,
-                                    src_stride, dst_stride,
-                                    itemsize);
-        *outtransferdata = NULL;
-    }
-    /* If complex, a paired swap */
-    else {
-        *outstransfer = PyArray_GetStridedCopySwapPairFn(aligned,
-                                    src_stride, dst_stride,
-                                    itemsize);
-        *outtransferdata = NULL;
-    }
-
-    return (*outstransfer == NULL) ? NPY_FAIL : NPY_SUCCEED;
-}
-
-/********************* MAIN DTYPE TRANSFER FUNCTION ***********************/
-
-NPY_NO_EXPORT int
-PyArray_GetDTypeTransferFunction(int aligned,
-                            npy_intp src_stride, npy_intp dst_stride,
-                            PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                            int move_references,
-                            PyArray_StridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    npy_intp src_itemsize, dst_itemsize;
-    int src_type_num, dst_type_num;
-
-#if NPY_DT_DBG_TRACING
-    printf("Calculating dtype transfer from ");
-    PyObject_Print((PyObject *)src_dtype, stdout, 0);
-    printf(" to ");
-    PyObject_Print((PyObject *)dst_dtype, stdout, 0);
-    printf("\n");
-#endif
-
-    /*
-     * If one of the dtypes is NULL, we give back either a src decref
-     * function or a dst setzero function
-     */
-    if (dst_dtype == NULL) {
-        if (move_references) {
-            return get_decsrcref_transfer_function(aligned,
-                                src_dtype->elsize,
-                                src_dtype,
-                                out_stransfer, out_transferdata,
-                                out_needs_api);
-        }
-        else {
-            *out_stransfer = &_dec_src_ref_nop;
-            *out_transferdata = NULL;
-            return NPY_SUCCEED;
-        }
-    }
-    else if (src_dtype == NULL) {
-        return get_setdstzero_transfer_function(aligned,
-                                dst_dtype->elsize,
-                                dst_dtype,
-                                out_stransfer, out_transferdata,
-                                out_needs_api);
-    }
-
-    src_itemsize = src_dtype->elsize;
-    dst_itemsize = dst_dtype->elsize;
-    src_type_num = src_dtype->type_num;
-    dst_type_num = dst_dtype->type_num;
-
-    /* Common special case - number -> number NBO cast */
-    if (PyTypeNum_ISNUMBER(src_type_num) &&
-                    PyTypeNum_ISNUMBER(dst_type_num) &&
-                    PyArray_ISNBO(src_dtype->byteorder) &&
-                    PyArray_ISNBO(dst_dtype->byteorder)) {
-
-        if (PyArray_EquivTypenums(src_type_num, dst_type_num)) {
-            *out_stransfer = PyArray_GetStridedCopyFn(aligned,
-                                        src_stride, dst_stride,
-                                        src_itemsize);
-            *out_transferdata = NULL;
-            return (*out_stransfer == NULL) ? NPY_FAIL : NPY_SUCCEED;
-        }
-        else {
-            return get_nbo_cast_numeric_transfer_function (aligned,
-                                        src_stride, dst_stride,
-                                        src_type_num, dst_type_num,
-                                        out_stransfer, out_transferdata);
-        }
-    }
-
-    /*
-     * If there are no references and the data types are equivalent,
-     * return a simple copy
-     */
-    if (!PyDataType_REFCHK(src_dtype) && !PyDataType_REFCHK(dst_dtype) &&
-                            PyArray_EquivTypes(src_dtype, dst_dtype)) {
-        /*
-         * We can't pass through the aligned flag because it's not
-         * appropriate. Consider a size-8 string, it will say it's
-         * aligned because strings only need alignment 1, but the
-         * copy function wants to know if it's alignment 8.
-         *
-         * TODO: Change align from a flag to a "best power of 2 alignment"
-         *       which holds the strongest alignment value for all
-         *       the data which will be used.
-         */
-        *out_stransfer = PyArray_GetStridedCopyFn(0,
-                                        src_stride, dst_stride,
-                                        src_dtype->elsize);
-        *out_transferdata = NULL;
-        return NPY_SUCCEED;
-    }
-
-    /* First look at the possibilities of just a copy or swap */
-    if (src_itemsize == dst_itemsize && src_dtype->kind == dst_dtype->kind &&
-                !PyDataType_HASFIELDS(src_dtype) &&
-                !PyDataType_HASFIELDS(dst_dtype) &&
-                !PyDataType_HASSUBARRAY(src_dtype) &&
-                !PyDataType_HASSUBARRAY(dst_dtype) &&
-                src_type_num != NPY_DATETIME && src_type_num != NPY_TIMEDELTA) {
-        /* A custom data type requires that we use its copy/swap */
-        if (src_type_num >= NPY_NTYPES || dst_type_num >= NPY_NTYPES) {
-            /*
-             * If the sizes and kinds are identical, but they're different
-             * custom types, then get a cast function
-             */
-            if (src_type_num != dst_type_num) {
-                return get_cast_transfer_function(aligned,
-                                src_stride, dst_stride,
-                                src_dtype, dst_dtype,
-                                move_references,
-                                out_stransfer, out_transferdata,
-                                out_needs_api);
-            }
-            else {
-                return wrap_copy_swap_function(aligned,
-                                src_stride, dst_stride,
-                                src_dtype,
-                                PyArray_ISNBO(src_dtype->byteorder) !=
-                                        PyArray_ISNBO(dst_dtype->byteorder),
-                                out_stransfer, out_transferdata);
-            }
-        }
-
-        /* The special types, which have no byte-order */
-        switch (src_type_num) {
-            case NPY_VOID:
-            case NPY_STRING:
-            case NPY_UNICODE:
-                *out_stransfer = PyArray_GetStridedCopyFn(0,
-                                    src_stride, dst_stride,
-                                    src_itemsize);
-                *out_transferdata = NULL;
-                return NPY_SUCCEED;
-            case NPY_OBJECT:
-                if (out_needs_api) {
-                    *out_needs_api = 1;
-                }
-                if (move_references) {
-                    *out_stransfer = &_strided_to_strided_move_references;
-                    *out_transferdata = NULL;
-                }
-                else {
-                    *out_stransfer = &_strided_to_strided_copy_references;
-                    *out_transferdata = NULL;
-                }
-                return NPY_SUCCEED;
-        }
-
-        /* This is a straight copy */
-        if (src_itemsize == 1 || PyArray_ISNBO(src_dtype->byteorder) ==
-                                 PyArray_ISNBO(dst_dtype->byteorder)) {
-            *out_stransfer = PyArray_GetStridedCopyFn(aligned,
-                                        src_stride, dst_stride,
-                                        src_itemsize);
-            *out_transferdata = NULL;
-            return (*out_stransfer == NULL) ? NPY_FAIL : NPY_SUCCEED;
-        }
-        /* This is a straight copy + byte swap */
-        else if (!PyTypeNum_ISCOMPLEX(src_type_num)) {
-            *out_stransfer = PyArray_GetStridedCopySwapFn(aligned,
-                                        src_stride, dst_stride,
-                                        src_itemsize);
-            *out_transferdata = NULL;
-            return (*out_stransfer == NULL) ? NPY_FAIL : NPY_SUCCEED;
-        }
-        /* This is a straight copy + element pair byte swap */
-        else {
-            *out_stransfer = PyArray_GetStridedCopySwapPairFn(aligned,
-                                        src_stride, dst_stride,
-                                        src_itemsize);
-            *out_transferdata = NULL;
-            return (*out_stransfer == NULL) ? NPY_FAIL : NPY_SUCCEED;
-        }
-    }
-
-    /* Handle subarrays */
-    if (PyDataType_HASSUBARRAY(src_dtype) ||
-                                PyDataType_HASSUBARRAY(dst_dtype)) {
-        return get_subarray_transfer_function(aligned,
-                        src_stride, dst_stride,
-                        src_dtype, dst_dtype,
-                        move_references,
-                        out_stransfer, out_transferdata,
-                        out_needs_api);
-    }
-
-    /* Handle fields */
-    if ((PyDataType_HASFIELDS(src_dtype) || PyDataType_HASFIELDS(dst_dtype)) &&
-            src_type_num != NPY_OBJECT && dst_type_num != NPY_OBJECT) {
-        return get_fields_transfer_function(aligned,
-                        src_stride, dst_stride,
-                        src_dtype, dst_dtype,
-                        move_references,
-                        out_stransfer, out_transferdata,
-                        out_needs_api);
-    }
-
-    /* Check for different-sized strings, unicodes, or voids */
-    if (src_type_num == dst_type_num) {
-        switch (src_type_num) {
-        case NPY_STRING:
-        case NPY_UNICODE:
-        case NPY_VOID:
-            return PyArray_GetStridedZeroPadCopyFn(0,
-                                    src_stride, dst_stride,
-                                    src_dtype->elsize, dst_dtype->elsize,
-                                    out_stransfer, out_transferdata);
-        }
-    }
-
-    /* Otherwise a cast is necessary */
-    return get_cast_transfer_function(aligned,
-                    src_stride, dst_stride,
-                    src_dtype, dst_dtype,
-                    move_references,
-                    out_stransfer, out_transferdata,
-                    out_needs_api);
-}
-
-NPY_NO_EXPORT int
-PyArray_GetMaskedDTypeTransferFunction(int aligned,
-                            npy_intp src_stride,
-                            npy_intp dst_stride,
-                            npy_intp mask_stride,
-                            PyArray_Descr *src_dtype,
-                            PyArray_Descr *dst_dtype,
-                            PyArray_Descr *mask_dtype,
-                            int move_references,
-                            PyArray_MaskedStridedUnaryOp **out_stransfer,
-                            NpyAuxData **out_transferdata,
-                            int *out_needs_api)
-{
-    PyArray_StridedUnaryOp *stransfer = NULL;
-    NpyAuxData *transferdata = NULL;
-    _masked_wrapper_transfer_data *data;
-
-    /* TODO: Add struct-based mask_dtype support later */
-    if (mask_dtype->type_num != NPY_BOOL &&
-                            mask_dtype->type_num != NPY_UINT8) {
-        PyErr_SetString(PyExc_TypeError,
-                "Only bool and uint8 masks are supported at the moment, "
-                "structs of bool/uint8 is planned for the future");
-        return NPY_FAIL;
-    }
-
-    /* TODO: Special case some important cases so they're fast */
-
-    /* Fall back to wrapping a non-masked transfer function */
-    if (PyArray_GetDTypeTransferFunction(aligned,
-                                src_stride, dst_stride,
-                                src_dtype, dst_dtype,
-                                move_references,
-                                &stransfer, &transferdata,
-                                out_needs_api) != NPY_SUCCEED) {
-        return NPY_FAIL;
-    }
-
-    /* Create the wrapper function's auxdata */
-    data = (_masked_wrapper_transfer_data *)PyArray_malloc(
-                            sizeof(_masked_wrapper_transfer_data));
-    if (data == NULL) {
-        PyErr_NoMemory();
-        NPY_AUXDATA_FREE(transferdata);
-        return NPY_FAIL;
-    }
-
-    /* Fill in the auxdata object */
-    memset(data, 0, sizeof(_masked_wrapper_transfer_data));
-    data->base.free = &_masked_wrapper_transfer_data_free;
-    data->base.clone = &_masked_wrapper_transfer_data_clone;
-
-    data->stransfer = stransfer;
-    data->transferdata = transferdata;
-
-    /* If the src object will need a DECREF, get a function to handle that */
-    if (move_references && PyDataType_REFCHK(src_dtype)) {
-        if (get_decsrcref_transfer_function(aligned,
-                            src_stride,
-                            src_dtype,
-                            &data->decsrcref_stransfer,
-                            &data->decsrcref_transferdata,
-                            out_needs_api) != NPY_SUCCEED) {
-            NPY_AUXDATA_FREE((NpyAuxData *)data);
-            return NPY_FAIL;
-        }
-
-        *out_stransfer = &_strided_masked_wrapper_decsrcref_transfer_function;
-    }
-    else {
-        *out_stransfer = &_strided_masked_wrapper_transfer_function;
-    }
-
-    *out_transferdata = (NpyAuxData *)data;
-
-    return NPY_SUCCEED;
-}
-
-NPY_NO_EXPORT int
-PyArray_CastRawArrays(npy_intp count,
-                      char *src, char *dst,
-                      npy_intp src_stride, npy_intp dst_stride,
-                      PyArray_Descr *src_dtype, PyArray_Descr *dst_dtype,
-                      int move_references)
-{
-    PyArray_StridedUnaryOp *stransfer = NULL;
-    NpyAuxData *transferdata = NULL;
-    int aligned = 1, needs_api = 0;
-
-    /* Make sure the copy is reasonable */
-    if (dst_stride == 0 && count > 1) {
-        PyErr_SetString(PyExc_ValueError,
-                    "NumPy CastRawArrays cannot do a reduction");
-        return NPY_FAIL;
-    }
-    else if (count == 0) {
-        return NPY_SUCCEED;
-    }
-
-    /* Check data alignment */
-    aligned = (((npy_intp)src | src_stride) &
-                                (src_dtype->alignment - 1)) == 0 &&
-              (((npy_intp)dst | dst_stride) &
-                                (dst_dtype->alignment - 1)) == 0;
-
-    /* Get the function to do the casting */
-    if (PyArray_GetDTypeTransferFunction(aligned,
-                        src_stride, dst_stride,
-                        src_dtype, dst_dtype,
-                        move_references,
-                        &stransfer, &transferdata,
-                        &needs_api) != NPY_SUCCEED) {
-        return NPY_FAIL;
-    }
-
-    /* Cast */
-    stransfer(dst, dst_stride, src, src_stride, count,
-                src_dtype->elsize, transferdata);
-
-    /* Cleanup */
-    NPY_AUXDATA_FREE(transferdata);
-
-    /* If needs_api was set to 1, it may have raised a Python exception */
-    return (needs_api && PyErr_Occurred()) ? NPY_FAIL : NPY_SUCCEED;
-}
-
-/*
- * Prepares shape and strides for a simple raw array iteration.
- * This sorts the strides into FORTRAN order, reverses any negative
- * strides, then coalesces axes where possible. The results are
- * filled in the output parameters.
- *
- * This is intended for simple, lightweight iteration over arrays
- * where no buffering of any kind is needed, and the array may
- * not be stored as a PyArrayObject.
- *
- * The arrays shape, out_shape, strides, and out_strides must all
- * point to different data.
- *
- * Returns 0 on success, -1 on failure.
- */
-NPY_NO_EXPORT int
-PyArray_PrepareOneRawArrayIter(int ndim, npy_intp *shape,
-                            char *data, npy_intp *strides,
-                            int *out_ndim, npy_intp *out_shape,
-                            char **out_data, npy_intp *out_strides)
-{
-    npy_stride_sort_item strideperm[NPY_MAXDIMS];
-    int i, j;
-
-    /* Special case 0 and 1 dimensions */
-    if (ndim == 0) {
-        *out_ndim = 1;
-        *out_data = data;
-        out_shape[0] = 1;
-        out_strides[0] = 0;
-        return 0;
-    }
-    else if (ndim == 1) {
-        npy_intp stride_entry = strides[0], shape_entry = shape[0];
-        *out_ndim = 1;
-        out_shape[0] = shape[0];
-        /* Always make a positive stride */
-        if (stride_entry >= 0) {
-            *out_data = data;
-            out_strides[0] = stride_entry;
-        }
-        else {
-            *out_data = data + stride_entry * (shape_entry - 1);
-            out_strides[0] = -stride_entry;
-        }
-        return 0;
-    }
-
-    /* Sort the axes based on the destination strides */
-    PyArray_CreateSortedStridePerm(ndim, strides, strideperm);
-    for (i = 0; i < ndim; ++i) {
-        int iperm = strideperm[ndim - i - 1].perm;
-        out_shape[i] = shape[iperm];
-        out_strides[i] = strides[iperm];
-    }
-
-    /* Reverse any negative strides */
-    for (i = 0; i < ndim; ++i) {
-        npy_intp stride_entry = out_strides[i], shape_entry = out_shape[i];
-
-        if (stride_entry < 0) {
-            data += stride_entry * (shape_entry - 1);
-            out_strides[i] = -stride_entry;
-        }
-        /* Detect 0-size arrays here */
-        if (shape_entry == 0) {
-            *out_ndim = 1;
-            *out_data = data;
-            out_shape[0] = 0;
-            out_strides[0] = 0;
-            return 0;
-        }
-    }
-
-    /* Coalesce any dimensions where possible */
-    i = 0;
-    for (j = 1; j < ndim; ++j) {
-        if (out_shape[i] == 1) {
-            /* Drop axis i */
-            out_shape[i] = out_shape[j];
-            out_strides[i] = out_strides[j];
-        }
-        else if (out_shape[j] == 1) {
-            /* Drop axis j */
-        }
-        else if (out_strides[i] * out_shape[i] == out_strides[j]) {
-            /* Coalesce axes i and j */
-            out_shape[i] *= out_shape[j];
-        }
-        else {
-            /* Can't coalesce, go to next i */
-            ++i;
-            out_shape[i] = out_shape[j];
-            out_strides[i] = out_strides[j];
-        }
-    }
-    ndim = i+1;
-
-#if 0
-    /* DEBUG */
-    {
-        printf("raw iter ndim %d\n", ndim);
-        printf("shape: ");
-        for (i = 0; i < ndim; ++i) {
-            printf("%d ", (int)out_shape[i]);
-        }
-        printf("\n");
-        printf("strides: ");
-        for (i = 0; i < ndim; ++i) {
-            printf("%d ", (int)out_strides[i]);
-        }
-        printf("\n");
-    }
-#endif
-
-    *out_data = data;
-    *out_ndim = ndim;
-    return 0;
-}
-
-/*
- * The same as PyArray_PrepareOneRawArrayIter, but for two
- * operands instead of one. Any broadcasting of the two operands
- * should have already been done before calling this function,
- * as the ndim and shape is only specified once for both operands.
- *
- * Only the strides of the first operand are used to reorder
- * the dimensions, no attempt to consider all the strides together
- * is made, as is done in the NpyIter object.
- *
- * You can use this together with NPY_RAW_ITER_START and
- * NPY_RAW_ITER_TWO_NEXT to handle the looping boilerplate of everything
- * but the innermost loop (which is for idim == 0).
- *
- * Returns 0 on success, -1 on failure.
- */
-NPY_NO_EXPORT int
-PyArray_PrepareTwoRawArrayIter(int ndim, npy_intp *shape,
-                            char *dataA, npy_intp *stridesA,
-                            char *dataB, npy_intp *stridesB,
-                            int *out_ndim, npy_intp *out_shape,
-                            char **out_dataA, npy_intp *out_stridesA,
-                            char **out_dataB, npy_intp *out_stridesB)
-{
-    npy_stride_sort_item strideperm[NPY_MAXDIMS];
-    int i, j;
-
-    /* Special case 0 and 1 dimensions */
-    if (ndim == 0) {
-        *out_ndim = 1;
-        *out_dataA = dataA;
-        *out_dataB = dataB;
-        out_shape[0] = 1;
-        out_stridesA[0] = 0;
-        out_stridesB[0] = 0;
-        return 0;
-    }
-    else if (ndim == 1) {
-        npy_intp stride_entryA = stridesA[0], stride_entryB = stridesB[0];
-        npy_intp shape_entry = shape[0];
-        *out_ndim = 1;
-        out_shape[0] = shape[0];
-        /* Always make a positive stride for the first operand */
-        if (stride_entryA >= 0) {
-            *out_dataA = dataA;
-            *out_dataB = dataB;
-            out_stridesA[0] = stride_entryA;
-            out_stridesB[0] = stride_entryB;
-        }
-        else {
-            *out_dataA = dataA + stride_entryA * (shape_entry - 1);
-            *out_dataB = dataB + stride_entryB * (shape_entry - 1);
-            out_stridesA[0] = -stride_entryA;
-            out_stridesB[0] = -stride_entryB;
-        }
-        return 0;
-    }
-
-    /* Sort the axes based on the destination strides */
-    PyArray_CreateSortedStridePerm(ndim, stridesA, strideperm);
-    for (i = 0; i < ndim; ++i) {
-        int iperm = strideperm[ndim - i - 1].perm;
-        out_shape[i] = shape[iperm];
-        out_stridesA[i] = stridesA[iperm];
-        out_stridesB[i] = stridesB[iperm];
-    }
-
-    /* Reverse any negative strides of operand A */
-    for (i = 0; i < ndim; ++i) {
-        npy_intp stride_entryA = out_stridesA[i];
-        npy_intp stride_entryB = out_stridesB[i];
-        npy_intp shape_entry = out_shape[i];
-
-        if (stride_entryA < 0) {
-            dataA += stride_entryA * (shape_entry - 1);
-            dataB += stride_entryB * (shape_entry - 1);
-            out_stridesA[i] = -stride_entryA;
-            out_stridesB[i] = -stride_entryB;
-        }
-        /* Detect 0-size arrays here */
-        if (shape_entry == 0) {
-            *out_ndim = 1;
-            *out_dataA = dataA;
-            *out_dataB = dataB;
-            out_shape[0] = 0;
-            out_stridesA[0] = 0;
-            out_stridesB[0] = 0;
-            return 0;
-        }
-    }
-
-    /* Coalesce any dimensions where possible */
-    i = 0;
-    for (j = 1; j < ndim; ++j) {
-        if (out_shape[i] == 1) {
-            /* Drop axis i */
-            out_shape[i] = out_shape[j];
-            out_stridesA[i] = out_stridesA[j];
-            out_stridesB[i] = out_stridesB[j];
-        }
-        else if (out_shape[j] == 1) {
-            /* Drop axis j */
-        }
-        else if (out_stridesA[i] * out_shape[i] == out_stridesA[j] &&
-                    out_stridesB[i] * out_shape[i] == out_stridesB[j]) {
-            /* Coalesce axes i and j */
-            out_shape[i] *= out_shape[j];
-        }
-        else {
-            /* Can't coalesce, go to next i */
-            ++i;
-            out_shape[i] = out_shape[j];
-            out_stridesA[i] = out_stridesA[j];
-            out_stridesB[i] = out_stridesB[j];
-        }
-    }
-    ndim = i+1;
-
-    *out_dataA = dataA;
-    *out_dataB = dataB;
-    *out_ndim = ndim;
-    return 0;
-}
-
-/*
- * The same as PyArray_PrepareOneRawArrayIter, but for three
- * operands instead of one. Any broadcasting of the three operands
- * should have already been done before calling this function,
- * as the ndim and shape is only specified once for all operands.
- *
- * Only the strides of the first operand are used to reorder
- * the dimensions, no attempt to consider all the strides together
- * is made, as is done in the NpyIter object.
- *
- * You can use this together with NPY_RAW_ITER_START and
- * NPY_RAW_ITER_THREE_NEXT to handle the looping boilerplate of everything
- * but the innermost loop (which is for idim == 0).
- *
- * Returns 0 on success, -1 on failure.
- */
-NPY_NO_EXPORT int
-PyArray_PrepareThreeRawArrayIter(int ndim, npy_intp *shape,
-                            char *dataA, npy_intp *stridesA,
-                            char *dataB, npy_intp *stridesB,
-                            char *dataC, npy_intp *stridesC,
-                            int *out_ndim, npy_intp *out_shape,
-                            char **out_dataA, npy_intp *out_stridesA,
-                            char **out_dataB, npy_intp *out_stridesB,
-                            char **out_dataC, npy_intp *out_stridesC)
-{
-    npy_stride_sort_item strideperm[NPY_MAXDIMS];
-    int i, j;
-
-    /* Special case 0 and 1 dimensions */
-    if (ndim == 0) {
-        *out_ndim = 1;
-        *out_dataA = dataA;
-        *out_dataB = dataB;
-        *out_dataC = dataC;
-        out_shape[0] = 1;
-        out_stridesA[0] = 0;
-        out_stridesB[0] = 0;
-        out_stridesC[0] = 0;
-        return 0;
-    }
-    else if (ndim == 1) {
-        npy_intp stride_entryA = stridesA[0];
-        npy_intp stride_entryB = stridesB[0];
-        npy_intp stride_entryC = stridesC[0];
-        npy_intp shape_entry = shape[0];
-        *out_ndim = 1;
-        out_shape[0] = shape[0];
-        /* Always make a positive stride for the first operand */
-        if (stride_entryA >= 0) {
-            *out_dataA = dataA;
-            *out_dataB = dataB;
-            *out_dataC = dataC;
-            out_stridesA[0] = stride_entryA;
-            out_stridesB[0] = stride_entryB;
-            out_stridesC[0] = stride_entryC;
-        }
-        else {
-            *out_dataA = dataA + stride_entryA * (shape_entry - 1);
-            *out_dataB = dataB + stride_entryB * (shape_entry - 1);
-            *out_dataC = dataC + stride_entryC * (shape_entry - 1);
-            out_stridesA[0] = -stride_entryA;
-            out_stridesB[0] = -stride_entryB;
-            out_stridesC[0] = -stride_entryC;
-        }
-        return 0;
-    }
-
-    /* Sort the axes based on the destination strides */
-    PyArray_CreateSortedStridePerm(ndim, stridesA, strideperm);
-    for (i = 0; i < ndim; ++i) {
-        int iperm = strideperm[ndim - i - 1].perm;
-        out_shape[i] = shape[iperm];
-        out_stridesA[i] = stridesA[iperm];
-        out_stridesB[i] = stridesB[iperm];
-        out_stridesC[i] = stridesC[iperm];
-    }
-
-    /* Reverse any negative strides of operand A */
-    for (i = 0; i < ndim; ++i) {
-        npy_intp stride_entryA = out_stridesA[i];
-        npy_intp stride_entryB = out_stridesB[i];
-        npy_intp stride_entryC = out_stridesC[i];
-        npy_intp shape_entry = out_shape[i];
-
-        if (stride_entryA < 0) {
-            dataA += stride_entryA * (shape_entry - 1);
-            dataB += stride_entryB * (shape_entry - 1);
-            dataC += stride_entryC * (shape_entry - 1);
-            out_stridesA[i] = -stride_entryA;
-            out_stridesB[i] = -stride_entryB;
-            out_stridesC[i] = -stride_entryC;
-        }
-        /* Detect 0-size arrays here */
-        if (shape_entry == 0) {
-            *out_ndim = 1;
-            *out_dataA = dataA;
-            *out_dataB = dataB;
-            *out_dataC = dataC;
-            out_shape[0] = 0;
-            out_stridesA[0] = 0;
-            out_stridesB[0] = 0;
-            out_stridesC[0] = 0;
-            return 0;
-        }
-    }
-
-    /* Coalesce any dimensions where possible */
-    i = 0;
-    for (j = 1; j < ndim; ++j) {
-        if (out_shape[i] == 1) {
-            /* Drop axis i */
-            out_shape[i] = out_shape[j];
-            out_stridesA[i] = out_stridesA[j];
-            out_stridesB[i] = out_stridesB[j];
-            out_stridesC[i] = out_stridesC[j];
-        }
-        else if (out_shape[j] == 1) {
-            /* Drop axis j */
-        }
-        else if (out_stridesA[i] * out_shape[i] == out_stridesA[j] &&
-                    out_stridesB[i] * out_shape[i] == out_stridesB[j] &&
-                    out_stridesC[i] * out_shape[i] == out_stridesC[j]) {
-            /* Coalesce axes i and j */
-            out_shape[i] *= out_shape[j];
-        }
-        else {
-            /* Can't coalesce, go to next i */
-            ++i;
-            out_shape[i] = out_shape[j];
-            out_stridesA[i] = out_stridesA[j];
-            out_stridesB[i] = out_stridesB[j];
-            out_stridesC[i] = out_stridesC[j];
-        }
-    }
-    ndim = i+1;
-
-    *out_dataA = dataA;
-    *out_dataB = dataB;
-    *out_dataC = dataC;
-    *out_ndim = ndim;
-    return 0;
-}