numpy/core/src/multiarray/calculation.c

Bug Summary

File:	numpy/core/src/multiarray/calculation.c
Warning:	line 407, column 17 PyObject ownership leak with reference count of 1

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name calculation.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-output=html -analyzer-checker=python -analyzer-disable-checker=deadcode -analyzer-config prune-paths=true,suppress-c++-stdlib=true,suppress-null-return-paths=false,crosscheck-with-z3=true,model-path=/opt/pyrefcon/lib/pyrefcon/models/models -analyzer-config experimental-enable-naive-ctu-analysis=true,ctu-dir=/tmp/pyrefcon/numpy/csa-scan,ctu-index-name=/tmp/pyrefcon/numpy/csa-scan/externalDefMap.txt,ctu-invocation-list=/tmp/pyrefcon/numpy/csa-scan/invocations.yaml,display-ctu-progress=false -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +sse -target-feature +sse2 -target-feature +sse3 -tune-cpu generic -debug-info-kind=limited -dwarf-version=4 -debugger-tuning=gdb -fcoverage-compilation-dir=/tmp/pyrefcon/numpy -resource-dir /opt/pyrefcon/lib/clang/13.0.0 -isystem /opt/pyrefcon/lib/pyrefcon/models/python3.8 -D NDEBUG -D _FORTIFY_SOURCE=2 -D NPY_INTERNAL_BUILD=1 -D HAVE_NPY_CONFIG_H=1 -D _FILE_OFFSET_BITS=64 -D _LARGEFILE_SOURCE=1 -D _LARGEFILE64_SOURCE=1 -I build/src.linux-x86_64-3.8/numpy/core/src/common -I build/src.linux-x86_64-3.8/numpy/core/src/umath -I numpy/core/include -I build/src.linux-x86_64-3.8/numpy/core/include/numpy -I build/src.linux-x86_64-3.8/numpy/distutils/include -I numpy/core/src/common -I numpy/core/src -I numpy/core -I numpy/core/src/npymath -I numpy/core/src/multiarray -I numpy/core/src/umath -I numpy/core/src/npysort -I numpy/core/src/_simd -I build/src.linux-x86_64-3.8/numpy/core/src/common -I build/src.linux-x86_64-3.8/numpy/core/src/npymath -internal-isystem /opt/pyrefcon/lib/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-result -Wsign-compare -Wall -Wformat -Werror=format-security -Wformat -Werror=format-security -Wdate-time -fdebug-compilation-dir=/tmp/pyrefcon/numpy -ferror-limit 19 -fwrapv -pthread -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/pyrefcon/numpy/csa-scan/reports -x c numpy/core/src/multiarray/calculation.c

numpy/core/src/multiarray/calculation.c

→

1#define PY_SSIZE_T_CLEAN
2#include <Python.h>
3#include "structmember.h"

5#define NPY_NO_DEPRECATED_API0x0000000E NPY_API_VERSION0x0000000E
6#define _MULTIARRAYMODULE
7#include "numpy/arrayobject.h"
8#include "lowlevel_strided_loops.h"

10#include "npy_config.h"

12#include "npy_pycompat.h"

14#include "common.h"
15#include "number.h"

17#include "calculation.h"
18#include "array_assign.h"

20static double
21power_of_ten(int n)
22{
  static const double p10[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8};
  double ret;
  if (n < 9) {
      ret = p10[n];
  }
  else {
      ret = 1e9;
      while (n-- > 9) {
          ret *= 10.;
      }
  }
  return ret;
35}

37/*NUMPY_API
* ArgMax
*/
40NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
41PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out)
42{
  PyArrayObject *ap = NULL((void*)0), *rp = NULL((void*)0);
  PyArray_ArgFunc* arg_func;
  char *ip;
  npy_intp *rptr;
  npy_intp i, n, m;
  int elsize;
  NPY_BEGIN_THREADS_DEFPyThreadState *_save=((void*)0);;

  if ((ap = (PyArrayObject *)PyArray_CheckAxis(op, &axis, 0)) == NULL((void*)0)) {
      return NULL((void*)0);
  }
  /*
   * We need to permute the array so that axis is placed at the end.
   * And all other dimensions are shifted left.
   */
  if (axis != PyArray_NDIM(ap)-1) {
      PyArray_Dims newaxes;
      npy_intp dims[NPY_MAXDIMS32];
      int j;

      newaxes.ptr = dims;
      newaxes.len = PyArray_NDIM(ap);
      for (j = 0; j < axis; j++) {
          dims[j] = j;
      }
      for (j = axis; j < PyArray_NDIM(ap) - 1; j++) {
          dims[j] = j + 1;
      }
      dims[PyArray_NDIM(ap) - 1] = axis;
      op = (PyArrayObject *)PyArray_Transpose(ap, &newaxes);
      Py_DECREF(ap)_Py_DECREF(((PyObject*)(ap)));
      if (op == NULL((void*)0)) {
          return NULL((void*)0);
      }
  }
  else {
      op = ap;
  }

  /* Will get native-byte order contiguous copy. */
  ap = (PyArrayObject *)PyArray_ContiguousFromAny((PyObject *)op,PyArray_FromAny((PyObject *)op, PyArray_DescrFromType(PyArray_DESCR
(op)->type_num), 1, 0, ((0x0001 | (0x0100 | 0x0400))), ((void
*)0))
                                PyArray_DESCR(op)->type_num, 1, 0)PyArray_FromAny((PyObject *)op, PyArray_DescrFromType(PyArray_DESCR
(op)->type_num), 1, 0, ((0x0001 | (0x0100 | 0x0400))), ((void
*)0));
  Py_DECREF(op)_Py_DECREF(((PyObject*)(op)));
  if (ap == NULL((void*)0)) {
      return NULL((void*)0);
  }
  arg_func = PyArray_DESCR(ap)->f->argmax;
  if (arg_func == NULL((void*)0)) {
      PyErr_SetString(PyExc_TypeError,
              "data type not ordered");
      goto fail;
  }
  elsize = PyArray_DESCR(ap)->elsize;
  m = PyArray_DIMS(ap)[PyArray_NDIM(ap)-1];
  if (m == 0) {
      PyErr_SetString(PyExc_ValueError,
              "attempt to get argmax of an empty sequence");
      goto fail;
  }

  if (!out) {
      rp = (PyArrayObject *)PyArray_NewFromDescr(
              Py_TYPE(ap)(((PyObject*)(ap))->ob_type), PyArray_DescrFromType(NPY_INTPNPY_LONG),
              PyArray_NDIM(ap) - 1, PyArray_DIMS(ap), NULL((void*)0), NULL((void*)0),
              0, (PyObject *)ap);
      if (rp == NULL((void*)0)) {
          goto fail;
      }
  }
  else {
      if ((PyArray_NDIM(out) != PyArray_NDIM(ap) - 1) ||
              !PyArray_CompareLists(PyArray_DIMS(out), PyArray_DIMS(ap),
                                    PyArray_NDIM(out))) {
          PyErr_SetString(PyExc_ValueError,
                  "output array does not match result of np.argmax.");
          goto fail;
      }
      rp = (PyArrayObject *)PyArray_FromArray(out,
                            PyArray_DescrFromType(NPY_INTPNPY_LONG),
                            NPY_ARRAY_CARRAY(0x0001 | (0x0100 | 0x0400)) | NPY_ARRAY_WRITEBACKIFCOPY0x2000);
      if (rp == NULL((void*)0)) {
          goto fail;
      }
  }

  NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(ap))do {if (!(((((PyArray_DESCR(ap)))->flags & (0x10)) == (
0x10)))) do {_save = PyEval_SaveThread();} while (0);;} while
 (0);;
  n = PyArray_SIZE(ap)PyArray_MultiplyList(PyArray_DIMS(ap), PyArray_NDIM(ap))/m;
  rptr = (npy_intp *)PyArray_DATA(rp);
  for (ip = PyArray_DATA(ap), i = 0; i < n; i++, ip += elsize*m) {
      arg_func(ip, m, rptr, ap);
      rptr += 1;
  }
  NPY_END_THREADS_DESCR(PyArray_DESCR(ap))do {if (!(((((PyArray_DESCR(ap)))->flags & (0x10)) == (
0x10)))) do { if (_save) { PyEval_RestoreThread(_save); _save
 = ((void*)0);} } while (0);; } while (0);;

  Py_DECREF(ap)_Py_DECREF(((PyObject*)(ap)));
  /* Trigger the UPDATEIFCOPY/WRTIEBACKIFCOPY if necessary */
  if (out != NULL((void*)0) && out != rp) {
      PyArray_ResolveWritebackIfCopy(rp);
      Py_DECREF(rp)_Py_DECREF(((PyObject*)(rp)));
      rp = out;
      Py_INCREF(rp)_Py_INCREF(((PyObject*)(rp)));
  }
  return (PyObject *)rp;

fail:
  Py_DECREF(ap)_Py_DECREF(((PyObject*)(ap)));
  Py_XDECREF(rp)_Py_XDECREF(((PyObject*)(rp)));
  return NULL((void*)0);
151}

153/*NUMPY_API
* ArgMin
*/
156NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
157PyArray_ArgMin(PyArrayObject *op, int axis, PyArrayObject *out)
158{
  PyArrayObject *ap = NULL((void*)0), *rp = NULL((void*)0);
  PyArray_ArgFunc* arg_func;
  char *ip;
  npy_intp *rptr;
  npy_intp i, n, m;
  int elsize;
  NPY_BEGIN_THREADS_DEFPyThreadState *_save=((void*)0);;

  if ((ap = (PyArrayObject *)PyArray_CheckAxis(op, &axis, 0)) == NULL((void*)0)) {
      return NULL((void*)0);
  }
  /*
   * We need to permute the array so that axis is placed at the end.
   * And all other dimensions are shifted left.
   */
  if (axis != PyArray_NDIM(ap)-1) {
      PyArray_Dims newaxes;
      npy_intp dims[NPY_MAXDIMS32];
      int i;

      newaxes.ptr = dims;
      newaxes.len = PyArray_NDIM(ap);
      for (i = 0; i < axis; i++) {
          dims[i] = i;
      }
      for (i = axis; i < PyArray_NDIM(ap) - 1; i++) {
          dims[i] = i + 1;
      }
      dims[PyArray_NDIM(ap) - 1] = axis;
      op = (PyArrayObject *)PyArray_Transpose(ap, &newaxes);
      Py_DECREF(ap)_Py_DECREF(((PyObject*)(ap)));
      if (op == NULL((void*)0)) {
          return NULL((void*)0);
      }
  }
  else {
      op = ap;
  }

  /* Will get native-byte order contiguous copy. */
  ap = (PyArrayObject *)PyArray_ContiguousFromAny((PyObject *)op,PyArray_FromAny((PyObject *)op, PyArray_DescrFromType(PyArray_DESCR
(op)->type_num), 1, 0, ((0x0001 | (0x0100 | 0x0400))), ((void
*)0))
                                PyArray_DESCR(op)->type_num, 1, 0)PyArray_FromAny((PyObject *)op, PyArray_DescrFromType(PyArray_DESCR
(op)->type_num), 1, 0, ((0x0001 | (0x0100 | 0x0400))), ((void
*)0));
  Py_DECREF(op)_Py_DECREF(((PyObject*)(op)));
  if (ap == NULL((void*)0)) {
      return NULL((void*)0);
  }
  arg_func = PyArray_DESCR(ap)->f->argmin;
  if (arg_func == NULL((void*)0)) {
      PyErr_SetString(PyExc_TypeError,
              "data type not ordered");
      goto fail;
  }
  elsize = PyArray_DESCR(ap)->elsize;
  m = PyArray_DIMS(ap)[PyArray_NDIM(ap)-1];
  if (m == 0) {
      PyErr_SetString(PyExc_ValueError,
              "attempt to get argmin of an empty sequence");
      goto fail;
  }

  if (!out) {
      rp = (PyArrayObject *)PyArray_NewFromDescr(
              Py_TYPE(ap)(((PyObject*)(ap))->ob_type), PyArray_DescrFromType(NPY_INTPNPY_LONG),
              PyArray_NDIM(ap) - 1, PyArray_DIMS(ap), NULL((void*)0), NULL((void*)0),
              0, (PyObject *)ap);
      if (rp == NULL((void*)0)) {
          goto fail;
      }
  }
  else {
      if ((PyArray_NDIM(out) != PyArray_NDIM(ap) - 1) ||
              !PyArray_CompareLists(PyArray_DIMS(out), PyArray_DIMS(ap),
                                    PyArray_NDIM(out))) {
          PyErr_SetString(PyExc_ValueError,
                  "output array does not match result of np.argmin.");
          goto fail;
      }
      rp = (PyArrayObject *)PyArray_FromArray(out,
                            PyArray_DescrFromType(NPY_INTPNPY_LONG),
                            NPY_ARRAY_CARRAY(0x0001 | (0x0100 | 0x0400)) | NPY_ARRAY_WRITEBACKIFCOPY0x2000);
      if (rp == NULL((void*)0)) {
          goto fail;
      }
  }

  NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(ap))do {if (!(((((PyArray_DESCR(ap)))->flags & (0x10)) == (
0x10)))) do {_save = PyEval_SaveThread();} while (0);;} while
 (0);;
  n = PyArray_SIZE(ap)PyArray_MultiplyList(PyArray_DIMS(ap), PyArray_NDIM(ap))/m;
  rptr = (npy_intp *)PyArray_DATA(rp);
  for (ip = PyArray_DATA(ap), i = 0; i < n; i++, ip += elsize*m) {
      arg_func(ip, m, rptr, ap);
      rptr += 1;
  }
  NPY_END_THREADS_DESCR(PyArray_DESCR(ap))do {if (!(((((PyArray_DESCR(ap)))->flags & (0x10)) == (
0x10)))) do { if (_save) { PyEval_RestoreThread(_save); _save
 = ((void*)0);} } while (0);; } while (0);;

  Py_DECREF(ap)_Py_DECREF(((PyObject*)(ap)));
  /* Trigger the UPDATEIFCOPY/WRITEBACKIFCOPY if necessary */
  if (out != NULL((void*)0) && out != rp) {
      PyArray_ResolveWritebackIfCopy(rp);
      Py_DECREF(rp)_Py_DECREF(((PyObject*)(rp)));
      rp = out;
      Py_INCREF(rp)_Py_INCREF(((PyObject*)(rp)));
  }
  return (PyObject *)rp;

fail:
  Py_DECREF(ap)_Py_DECREF(((PyObject*)(ap)));
  Py_XDECREF(rp)_Py_XDECREF(((PyObject*)(rp)));
  return NULL((void*)0);
267}

269/*NUMPY_API
* Max
*/
272NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
273PyArray_Max(PyArrayObject *ap, int axis, PyArrayObject *out)
274{
  PyArrayObject *arr;
  PyObject *ret;

  arr = (PyArrayObject *)PyArray_CheckAxis(ap, &axis, 0);
  if (arr == NULL((void*)0)) {
      return NULL((void*)0);
  }
  ret = PyArray_GenericReduceFunction(arr, n_ops.maximum, axis,
                                      PyArray_DESCR(arr)->type_num, out);
  Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
  return ret;
286}

288/*NUMPY_API
* Min
*/
291NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
292PyArray_Min(PyArrayObject *ap, int axis, PyArrayObject *out)
293{
  PyArrayObject *arr;
  PyObject *ret;

  arr=(PyArrayObject *)PyArray_CheckAxis(ap, &axis, 0);
  if (arr == NULL((void*)0)) {
      return NULL((void*)0);
  }
  ret = PyArray_GenericReduceFunction(arr, n_ops.minimum, axis,
                                      PyArray_DESCR(arr)->type_num, out);
  Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
  return ret;
305}

307/*NUMPY_API
* Ptp
*/
310NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
311PyArray_Ptp(PyArrayObject *ap, int axis, PyArrayObject *out)
312{
  PyArrayObject *arr;
  PyObject *ret;
  PyObject *obj1 = NULL((void*)0), *obj2 = NULL((void*)0);

  arr=(PyArrayObject *)PyArray_CheckAxis(ap, &axis, 0);
  if (arr == NULL((void*)0)) {
      return NULL((void*)0);
  }
  obj1 = PyArray_Max(arr, axis, out);
  if (obj1 == NULL((void*)0)) {
      goto fail;
  }
  obj2 = PyArray_Min(arr, axis, NULL((void*)0));
  if (obj2 == NULL((void*)0)) {
      goto fail;
  }
  Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
  if (out) {
      ret = PyObject_CallFunction_PyObject_CallFunction_SizeT(n_ops.subtract, "OOO", out, obj2, out);
  }
  else {
      ret = PyNumber_Subtract(obj1, obj2);
  }
  Py_DECREF(obj1)_Py_DECREF(((PyObject*)(obj1)));
  Py_DECREF(obj2)_Py_DECREF(((PyObject*)(obj2)));
  return ret;

fail:
  Py_XDECREF(arr)_Py_XDECREF(((PyObject*)(arr)));
  Py_XDECREF(obj1)_Py_XDECREF(((PyObject*)(obj1)));
  Py_XDECREF(obj2)_Py_XDECREF(((PyObject*)(obj2)));
  return NULL((void*)0);
345}



349/*NUMPY_API
* Set variance to 1 to by-pass square-root calculation and return variance
* Std
*/
353NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
354PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject *out,
          int variance)
356{
  return __New_PyArray_Std(self, axis, rtype, out, variance, 0);
1
Calling '__New_PyArray_Std'→
358}

360NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
361__New_PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject *out,
                int variance, int num)
363{
  PyObject *obj1 = NULL((void*)0), *obj2 = NULL((void*)0), *obj3 = NULL((void*)0);
  PyArrayObject *arr1 = NULL((void*)0), *arr2 = NULL((void*)0), *arrnew = NULL((void*)0);
  PyObject *ret = NULL((void*)0), *newshape = NULL((void*)0);
  int i, n;
  npy_intp val;

  arrnew = (PyArrayObject *)PyArray_CheckAxis(self, &axis, 0);
  if (arrnew1.1
'arrnew' is not equal to NULL
1
'arrnew' is not equal to NULL
1
'arrnew' is not equal to NULL
 == NULL((void*)0)) {
2
←
Taking false branch→
      return NULL((void*)0);
  }
  /* Compute and reshape mean */
  arr1 = (PyArrayObject *)PyArray_EnsureAnyArray(
                  PyArray_Mean(arrnew, axis, rtype, NULL((void*)0)));
  if (arr12.1
'arr1' is not equal to NULL
1
'arr1' is not equal to NULL
1
'arr1' is not equal to NULL
 == NULL((void*)0)) {
3
←
Taking false branch→
      Py_DECREF(arrnew)_Py_DECREF(((PyObject*)(arrnew)));
      return NULL((void*)0);
  }
  n = PyArray_NDIM(arrnew);
  newshape = PyTuple_New(n);
  if (newshape == NULL((void*)0)) {
4
←
Assuming 'newshape' is not equal to NULL→
5
←
Taking false branch→
      Py_DECREF(arr1)_Py_DECREF(((PyObject*)(arr1)));
      Py_DECREF(arrnew)_Py_DECREF(((PyObject*)(arrnew)));
      return NULL((void*)0);
  }
  for (i = 0; i < n; i++) {
6
←
Assuming 'i' is >= 'n'→
7
←
Loop condition is false. Execution continues on line 397→
      if (i == axis) {
          val = 1;
      }
      else {
          val = PyArray_DIM(arrnew,i);
      }
      PyTuple_SET_ITEM(newshape, i, PyLong_FromSsize_t(val))PyTuple_SetItem(newshape, i, PyLong_FromSsize_t(val));
  }
  arr2 = (PyArrayObject *)PyArray_Reshape(arr1, newshape);
  Py_DECREF(arr1)_Py_DECREF(((PyObject*)(arr1)));
  Py_DECREF(newshape)_Py_DECREF(((PyObject*)(newshape)));
  if (arr2 == NULL((void*)0)) {
8
←
Assuming 'arr2' is not equal to NULL→
9
←
Taking false branch→
      Py_DECREF(arrnew)_Py_DECREF(((PyObject*)(arrnew)));
      return NULL((void*)0);
  }

  /* Compute x = x - mx */
  arr1 = (PyArrayObject *)PyArray_EnsureAnyArray(
13
←
Calling 'PyArray_EnsureAnyArray'→
16
←
Returning from 'PyArray_EnsureAnyArray'→
              PyNumber_Subtract((PyObject *)arrnew, (PyObject *)arr2));
10
←
Calling 'PyNumber_Subtract'→
12
←
Returning from 'PyNumber_Subtract'→
23
←
PyObject ownership leak with reference count of 1
  Py_DECREF(arr2)_Py_DECREF(((PyObject*)(arr2)));
  if (arr116.1
'arr1' is not equal to NULL
1
'arr1' is not equal to NULL
1
'arr1' is not equal to NULL
 == NULL((void*)0)) {
17
←
Taking false branch→
      Py_DECREF(arrnew)_Py_DECREF(((PyObject*)(arrnew)));
      return NULL((void*)0);
  }
  /* Compute x * x */
  if (PyArray_ISCOMPLEX(arr1)(((PyArray_TYPE(arr1)) >= NPY_CFLOAT) && ((PyArray_TYPE
(arr1)) <= NPY_CLONGDOUBLE))) {
18
←
Assuming the condition is true→
19
←
Assuming the condition is true→
20
←
Taking true branch→
      obj3 = PyArray_Conjugate(arr1, NULL((void*)0));
  }
  else {
      obj3 = (PyObject *)arr1;
      Py_INCREF(arr1)_Py_INCREF(((PyObject*)(arr1)));
  }
  if (obj3 == NULL((void*)0)) {
21
←
Assuming 'obj3' is equal to NULL→
22
←
Taking true branch→
      Py_DECREF(arrnew)_Py_DECREF(((PyObject*)(arrnew)));
      return NULL((void*)0);
  }
  arr2 = (PyArrayObject *)PyArray_EnsureAnyArray(
              PyArray_GenericBinaryFunction((PyObject *)arr1, obj3,
                                             n_ops.multiply));
  Py_DECREF(arr1)_Py_DECREF(((PyObject*)(arr1)));
  Py_DECREF(obj3)_Py_DECREF(((PyObject*)(obj3)));
  if (arr2 == NULL((void*)0)) {
      Py_DECREF(arrnew)_Py_DECREF(((PyObject*)(arrnew)));
      return NULL((void*)0);
  }
  if (PyArray_ISCOMPLEX(arr2)(((PyArray_TYPE(arr2)) >= NPY_CFLOAT) && ((PyArray_TYPE
(arr2)) <= NPY_CLONGDOUBLE))) {
      obj3 = PyObject_GetAttrString((PyObject *)arr2, "real");
      switch(rtype) {
      case NPY_CDOUBLE:
          rtype = NPY_DOUBLE;
          break;
      case NPY_CFLOAT:
          rtype = NPY_FLOAT;
          break;
      case NPY_CLONGDOUBLE:
          rtype = NPY_LONGDOUBLE;
          break;
      }
  }
  else {
      obj3 = (PyObject *)arr2;
      Py_INCREF(arr2)_Py_INCREF(((PyObject*)(arr2)));
  }
  if (obj3 == NULL((void*)0)) {
      Py_DECREF(arrnew)_Py_DECREF(((PyObject*)(arrnew)));
      return NULL((void*)0);
  }
  /* Compute add.reduce(x*x,axis) */
  obj1 = PyArray_GenericReduceFunction((PyArrayObject *)obj3, n_ops.add,
                                       axis, rtype, NULL((void*)0));
  Py_DECREF(obj3)_Py_DECREF(((PyObject*)(obj3)));
  Py_DECREF(arr2)_Py_DECREF(((PyObject*)(arr2)));
  if (obj1 == NULL((void*)0)) {
      Py_DECREF(arrnew)_Py_DECREF(((PyObject*)(arrnew)));
      return NULL((void*)0);
  }
  n = PyArray_DIM(arrnew,axis);
  Py_DECREF(arrnew)_Py_DECREF(((PyObject*)(arrnew)));
  n = (n-num);
  if (n == 0) {
      n = 1;
  }
  obj2 = PyFloat_FromDouble(1.0/((double )n));
  if (obj2 == NULL((void*)0)) {
      Py_DECREF(obj1)_Py_DECREF(((PyObject*)(obj1)));
      return NULL((void*)0);
  }
  ret = PyNumber_Multiply(obj1, obj2);
  Py_DECREF(obj1)_Py_DECREF(((PyObject*)(obj1)));
  Py_DECREF(obj2)_Py_DECREF(((PyObject*)(obj2)));

  if (!variance) {
      arr1 = (PyArrayObject *)PyArray_EnsureAnyArray(ret);
      /* sqrt() */
      ret = PyArray_GenericUnaryFunction(arr1, n_ops.sqrt);
      Py_DECREF(arr1)_Py_DECREF(((PyObject*)(arr1)));
  }
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }
  if (PyArray_CheckExact(self)(((PyObject*)(self))->ob_type == &PyArray_Type)) {
      goto finish;
  }
  if (PyArray_Check(self)((((PyObject*)(self))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(self))->ob_type), (&PyArray_Type))) && Py_TYPE(self)(((PyObject*)(self))->ob_type) == Py_TYPE(ret)(((PyObject*)(ret))->ob_type)) {
      goto finish;
  }
  arr1 = (PyArrayObject *)PyArray_EnsureArray(ret);
  if (arr1 == NULL((void*)0)) {
      return NULL((void*)0);
  }
  ret = PyArray_View(arr1, NULL((void*)0), Py_TYPE(self)(((PyObject*)(self))->ob_type));
  Py_DECREF(arr1)_Py_DECREF(((PyObject*)(arr1)));

502finish:
  if (out) {
      if (PyArray_AssignArray(out, (PyArrayObject *)ret,
                  NULL((void*)0), NPY_DEFAULT_ASSIGN_CASTING) < 0) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return NULL((void*)0);
      }
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      Py_INCREF(out)_Py_INCREF(((PyObject*)(out)));
      return (PyObject *)out;
  }
  return ret;
514}


517/*NUMPY_API
*Sum
*/
520NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
521PyArray_Sum(PyArrayObject *self, int axis, int rtype, PyArrayObject *out)
522{
  PyObject *arr, *ret;

  arr = PyArray_CheckAxis(self, &axis, 0);
  if (arr == NULL((void*)0)) {
      return NULL((void*)0);
  }
  ret = PyArray_GenericReduceFunction((PyArrayObject *)arr, n_ops.add, axis,
                                      rtype, out);
  Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
  return ret;
533}

535/*NUMPY_API
* Prod
*/
538NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
539PyArray_Prod(PyArrayObject *self, int axis, int rtype, PyArrayObject *out)
540{
  PyObject *arr, *ret;

  arr = PyArray_CheckAxis(self, &axis, 0);
  if (arr == NULL((void*)0)) {
      return NULL((void*)0);
  }
  ret = PyArray_GenericReduceFunction((PyArrayObject *)arr,
                                      n_ops.multiply, axis,
                                      rtype, out);
  Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
  return ret;
552}

554/*NUMPY_API
*CumSum
*/
557NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
558PyArray_CumSum(PyArrayObject *self, int axis, int rtype, PyArrayObject *out)
559{
  PyObject *arr, *ret;

  arr = PyArray_CheckAxis(self, &axis, 0);
  if (arr == NULL((void*)0)) {
      return NULL((void*)0);
  }
  ret = PyArray_GenericAccumulateFunction((PyArrayObject *)arr,
                                          n_ops.add, axis,
                                          rtype, out);
  Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
  return ret;
571}

573/*NUMPY_API
* CumProd
*/
576NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
577PyArray_CumProd(PyArrayObject *self, int axis, int rtype, PyArrayObject *out)
578{
  PyObject *arr, *ret;

  arr = PyArray_CheckAxis(self, &axis, 0);
  if (arr == NULL((void*)0)) {
      return NULL((void*)0);
  }

  ret = PyArray_GenericAccumulateFunction((PyArrayObject *)arr,
                                          n_ops.multiply, axis,
                                          rtype, out);
  Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
  return ret;
591}

593/*NUMPY_API
* Round
*/
596NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
597PyArray_Round(PyArrayObject *a, int decimals, PyArrayObject *out)
598{
  PyObject *f, *ret = NULL((void*)0), *tmp, *op1, *op2;
  int ret_int=0;
  PyArray_Descr *my_descr;
  if (out && (PyArray_SIZE(out)PyArray_MultiplyList(PyArray_DIMS(out), PyArray_NDIM(out)) != PyArray_SIZE(a)PyArray_MultiplyList(PyArray_DIMS(a), PyArray_NDIM(a)))) {
      PyErr_SetString(PyExc_ValueError,
                      "invalid output shape");
      return NULL((void*)0);
  }
  if (PyArray_ISCOMPLEX(a)(((PyArray_TYPE(a)) >= NPY_CFLOAT) && ((PyArray_TYPE
(a)) <= NPY_CLONGDOUBLE))) {
      PyObject *part;
      PyObject *round_part;
      PyObject *arr;
      int res;

      if (out) {
          arr = (PyObject *)out;
          Py_INCREF(arr)_Py_INCREF(((PyObject*)(arr)));
      }
      else {
          arr = PyArray_Copy(a)PyArray_NewCopy(a, NPY_CORDER);
          if (arr == NULL((void*)0)) {
              return NULL((void*)0);
          }
      }

      /* arr.real = a.real.round(decimals) */
      part = PyObject_GetAttrString((PyObject *)a, "real");
      if (part == NULL((void*)0)) {
          Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
          return NULL((void*)0);
      }
      part = PyArray_EnsureAnyArray(part);
      round_part = PyArray_Round((PyArrayObject *)part,
                                 decimals, NULL((void*)0));
      Py_DECREF(part)_Py_DECREF(((PyObject*)(part)));
      if (round_part == NULL((void*)0)) {
          Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
          return NULL((void*)0);
      }
      res = PyObject_SetAttrString(arr, "real", round_part);
      Py_DECREF(round_part)_Py_DECREF(((PyObject*)(round_part)));
      if (res < 0) {
          Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
          return NULL((void*)0);
      }

      /* arr.imag = a.imag.round(decimals) */
      part = PyObject_GetAttrString((PyObject *)a, "imag");
      if (part == NULL((void*)0)) {
          Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
          return NULL((void*)0);
      }
      part = PyArray_EnsureAnyArray(part);
      round_part = PyArray_Round((PyArrayObject *)part,
                                 decimals, NULL((void*)0));
      Py_DECREF(part)_Py_DECREF(((PyObject*)(part)));
      if (round_part == NULL((void*)0)) {
          Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
          return NULL((void*)0);
      }
      res = PyObject_SetAttrString(arr, "imag", round_part);
      Py_DECREF(round_part)_Py_DECREF(((PyObject*)(round_part)));
      if (res < 0) {
          Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
          return NULL((void*)0);
      }
      return arr;
  }
  /* do the most common case first */
  if (decimals >= 0) {
      if (PyArray_ISINTEGER(a)(((PyArray_TYPE(a)) >= NPY_BYTE) && ((PyArray_TYPE
(a)) <= NPY_ULONGLONG))) {
          if (out) {
              if (PyArray_AssignArray(out, a,
                          NULL((void*)0), NPY_DEFAULT_ASSIGN_CASTING) < 0) {
                  return NULL((void*)0);
              }
              Py_INCREF(out)_Py_INCREF(((PyObject*)(out)));
              return (PyObject *)out;
          }
          else {
              Py_INCREF(a)_Py_INCREF(((PyObject*)(a)));
              return (PyObject *)a;
          }
      }
      if (decimals == 0) {
          if (out) {
              return PyObject_CallFunction_PyObject_CallFunction_SizeT(n_ops.rint, "OO", a, out);
          }
          return PyObject_CallFunction_PyObject_CallFunction_SizeT(n_ops.rint, "O", a);
      }
      op1 = n_ops.multiply;
      op2 = n_ops.true_divide;
  }
  else {
      op1 = n_ops.true_divide;
      op2 = n_ops.multiply;
      decimals = -decimals;
  }
  if (!out) {
      if (PyArray_ISINTEGER(a)(((PyArray_TYPE(a)) >= NPY_BYTE) && ((PyArray_TYPE
(a)) <= NPY_ULONGLONG))) {
          ret_int = 1;
          my_descr = PyArray_DescrFromType(NPY_DOUBLE);
      }
      else {
          Py_INCREF(PyArray_DESCR(a))_Py_INCREF(((PyObject*)(PyArray_DESCR(a))));
          my_descr = PyArray_DESCR(a);
      }
      out = (PyArrayObject *)PyArray_Empty(PyArray_NDIM(a), PyArray_DIMS(a),
                                           my_descr,
                                           PyArray_ISFORTRAN(a)(PyArray_CHKFLAGS(a, 0x0002) && (!PyArray_CHKFLAGS(a,
 0x0001))));
      if (out == NULL((void*)0)) {
          return NULL((void*)0);
      }
  }
  else {
      Py_INCREF(out)_Py_INCREF(((PyObject*)(out)));
  }
  f = PyFloat_FromDouble(power_of_ten(decimals));
  if (f == NULL((void*)0)) {
      return NULL((void*)0);
  }
  ret = PyObject_CallFunction_PyObject_CallFunction_SizeT(op1, "OOO", a, f, out);
  if (ret == NULL((void*)0)) {
      goto finish;
  }
  tmp = PyObject_CallFunction_PyObject_CallFunction_SizeT(n_ops.rint, "OO", ret, ret);
  if (tmp == NULL((void*)0)) {
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      ret = NULL((void*)0);
      goto finish;
  }
  Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
  tmp = PyObject_CallFunction_PyObject_CallFunction_SizeT(op2, "OOO", ret, f, ret);
  if (tmp == NULL((void*)0)) {
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      ret = NULL((void*)0);
      goto finish;
  }
  Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));

finish:
  Py_DECREF(f)_Py_DECREF(((PyObject*)(f)));
  Py_DECREF(out)_Py_DECREF(((PyObject*)(out)));
  if (ret_int) {
      Py_INCREF(PyArray_DESCR(a))_Py_INCREF(((PyObject*)(PyArray_DESCR(a))));
      tmp = PyArray_CastToType((PyArrayObject *)ret,
                               PyArray_DESCR(a), PyArray_ISFORTRAN(a)(PyArray_CHKFLAGS(a, 0x0002) && (!PyArray_CHKFLAGS(a,
 0x0001))));
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      return tmp;
  }
  return ret;
750}


753/*NUMPY_API
* Mean
*/
756NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
757PyArray_Mean(PyArrayObject *self, int axis, int rtype, PyArrayObject *out)
758{
  PyObject *obj1 = NULL((void*)0), *obj2 = NULL((void*)0), *ret;
  PyArrayObject *arr;

  arr = (PyArrayObject *)PyArray_CheckAxis(self, &axis, 0);
  if (arr == NULL((void*)0)) {
      return NULL((void*)0);
  }
  obj1 = PyArray_GenericReduceFunction(arr, n_ops.add, axis,
                                       rtype, out);
  obj2 = PyFloat_FromDouble((double)PyArray_DIM(arr,axis));
  Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
  if (obj1 == NULL((void*)0) || obj2 == NULL((void*)0)) {
      Py_XDECREF(obj1)_Py_XDECREF(((PyObject*)(obj1)));
      Py_XDECREF(obj2)_Py_XDECREF(((PyObject*)(obj2)));
      return NULL((void*)0);
  }
  if (!out) {
      ret = PyNumber_TrueDivide(obj1, obj2);
  }
  else {
      ret = PyObject_CallFunction_PyObject_CallFunction_SizeT(n_ops.divide, "OOO", out, obj2, out);
  }
  Py_DECREF(obj1)_Py_DECREF(((PyObject*)(obj1)));
  Py_DECREF(obj2)_Py_DECREF(((PyObject*)(obj2)));
  return ret;
784}

786/*NUMPY_API
* Any
*/
789NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
790PyArray_Any(PyArrayObject *self, int axis, PyArrayObject *out)
791{
  PyObject *arr, *ret;

  arr = PyArray_CheckAxis(self, &axis, 0);
  if (arr == NULL((void*)0)) {
      return NULL((void*)0);
  }
  ret = PyArray_GenericReduceFunction((PyArrayObject *)arr,
                                      n_ops.logical_or, axis,
                                      NPY_BOOL, out);
  Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
  return ret;
803}

805/*NUMPY_API
* All
*/
808NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
809PyArray_All(PyArrayObject *self, int axis, PyArrayObject *out)
810{
  PyObject *arr, *ret;

  arr = PyArray_CheckAxis(self, &axis, 0);
  if (arr == NULL((void*)0)) {
      return NULL((void*)0);
  }
  ret = PyArray_GenericReduceFunction((PyArrayObject *)arr,
                                      n_ops.logical_and, axis,
                                      NPY_BOOL, out);
  Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
  return ret;
822}


825static PyObject *
826_GenericBinaryOutFunction(PyArrayObject *m1, PyObject *m2, PyArrayObject *out,
                        PyObject *op)
828{
  if (out == NULL((void*)0)) {
      return PyObject_CallFunction_PyObject_CallFunction_SizeT(op, "OO", m1, m2);
  }
  else {
      PyObject *args, *ret;
      static PyObject *kw = NULL((void*)0);

      if (kw == NULL((void*)0)) {
          kw = Py_BuildValue_Py_BuildValue_SizeT("{s:s}", "casting", "unsafe");
          if (kw == NULL((void*)0)) {
              return NULL((void*)0);
          }
      }

      args = Py_BuildValue_Py_BuildValue_SizeT("OOO", m1, m2, out);
      if (args == NULL((void*)0)) {
          return NULL((void*)0);
      }

      ret = PyObject_Call(op, args, kw);

      Py_DECREF(args)_Py_DECREF(((PyObject*)(args)));

      return ret;
  }
854}

856static PyObject *
857_slow_array_clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *out)
858{
  PyObject *res1=NULL((void*)0), *res2=NULL((void*)0);

  if (max != NULL((void*)0)) {
      res1 = _GenericBinaryOutFunction(self, max, out, n_ops.minimum);
      if (res1 == NULL((void*)0)) {
          return NULL((void*)0);
      }
  }
  else {
      res1 = (PyObject *)self;
      Py_INCREF(res1)_Py_INCREF(((PyObject*)(res1)));
  }

  if (min != NULL((void*)0)) {
      res2 = _GenericBinaryOutFunction((PyArrayObject *)res1,
                                       min, out, n_ops.maximum);
      if (res2 == NULL((void*)0)) {
          Py_XDECREF(res1)_Py_XDECREF(((PyObject*)(res1)));
          return NULL((void*)0);
      }
  }
  else {
      res2 = res1;
      Py_INCREF(res2)_Py_INCREF(((PyObject*)(res2)));
  }
  Py_DECREF(res1)_Py_DECREF(((PyObject*)(res1)));
  return res2;
886}

888/*NUMPY_API
* Clip
*/
891NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
892PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *out)
893{
  PyArray_FastClipFunc *func;
  int outgood = 0, ingood = 0;
  PyArrayObject *maxa = NULL((void*)0);
  PyArrayObject *mina = NULL((void*)0);
  PyArrayObject *newout = NULL((void*)0), *newin = NULL((void*)0);
  PyArray_Descr *indescr = NULL((void*)0), *newdescr = NULL((void*)0);
  char *max_data, *min_data;
  PyObject *zero;

  /* Treat None the same as NULL */
  if (min == Py_None(&_Py_NoneStruct)) {
      min = NULL((void*)0);
  }
  if (max == Py_None(&_Py_NoneStruct)) {
      max = NULL((void*)0);
  }

  if ((max == NULL((void*)0)) && (min == NULL((void*)0))) {
      PyErr_SetString(PyExc_ValueError,
                      "array_clip: must set either max or min");
      return NULL((void*)0);
  }

  func = PyArray_DESCR(self)->f->fastclip;
  if (func == NULL((void*)0)) {
      if (min == NULL((void*)0)) {
          return PyObject_CallFunctionObjArgs(n_ops.minimum, self, max, out, NULL((void*)0));
      }
      else if (max == NULL((void*)0)) {
          return PyObject_CallFunctionObjArgs(n_ops.maximum, self, min, out, NULL((void*)0));
      }
      else {
          return PyObject_CallFunctionObjArgs(n_ops.clip, self, min, max, out, NULL((void*)0));
      }
  }

  /*
   * NumPy 1.17.0, 2019-02-24
   * NumPy 1.19.0, 2020-01-15
   *
   * Setting `->f->fastclip to anything but NULL has been deprecated in 1.19
   * the code path below was previously deprecated since 1.17.
   * (the deprecation moved to registration time instead of execution time)
   * everything below can be removed once this deprecation completes
   */

  if (func == NULL((void*)0)
      || (min != NULL((void*)0) && !PyArray_CheckAnyScalar(min)(((((((PyObject*)(min))->ob_type) == (&PyFloat_Type) ||
 PyType_IsSubtype((((PyObject*)(min))->ob_type), (&PyFloat_Type
))) || ((((PyObject*)(min))->ob_type) == (&PyComplex_Type
) || PyType_IsSubtype((((PyObject*)(min))->ob_type), (&
PyComplex_Type))) || ((((((PyObject*)(min))->ob_type))->
tp_flags & ((1UL << 24))) != 0) || ((((PyObject*)(min
))->ob_type) == &PyBool_Type)) || ((((((PyObject*)(min
))->ob_type))->tp_flags & ((1UL << 27))) != 0
) || ((((((PyObject*)(min))->ob_type))->tp_flags & (
(1UL << 28))) != 0)) || ((((((PyObject*)(min))->ob_type
) == (&PyGenericArrType_Type) || PyType_IsSubtype((((PyObject
*)(min))->ob_type), (&PyGenericArrType_Type)))) || (((
((PyObject*)(min))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(min))->ob_type), (&PyArray_Type))) &&
 (PyArray_NDIM((PyArrayObject *)min) == 0)))))
      || (max != NULL((void*)0) && !PyArray_CheckAnyScalar(max)(((((((PyObject*)(max))->ob_type) == (&PyFloat_Type) ||
 PyType_IsSubtype((((PyObject*)(max))->ob_type), (&PyFloat_Type
))) || ((((PyObject*)(max))->ob_type) == (&PyComplex_Type
) || PyType_IsSubtype((((PyObject*)(max))->ob_type), (&
PyComplex_Type))) || ((((((PyObject*)(max))->ob_type))->
tp_flags & ((1UL << 24))) != 0) || ((((PyObject*)(max
))->ob_type) == &PyBool_Type)) || ((((((PyObject*)(max
))->ob_type))->tp_flags & ((1UL << 27))) != 0
) || ((((((PyObject*)(max))->ob_type))->tp_flags & (
(1UL << 28))) != 0)) || ((((((PyObject*)(max))->ob_type
) == (&PyGenericArrType_Type) || PyType_IsSubtype((((PyObject
*)(max))->ob_type), (&PyGenericArrType_Type)))) || (((
((PyObject*)(max))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(max))->ob_type), (&PyArray_Type))) &&
 (PyArray_NDIM((PyArrayObject *)max) == 0)))))
      || PyArray_ISBYTESWAPPED(self)(!((PyArray_DESCR(self)->byteorder) != '>'))
      || (out && PyArray_ISBYTESWAPPED(out)(!((PyArray_DESCR(out)->byteorder) != '>')))) {
      return _slow_array_clip(self, min, max, out);
  }
  /* Use the fast scalar clip function */

  /* First we need to figure out the correct type */
  if (min != NULL((void*)0)) {
      indescr = PyArray_DescrFromObject(min, NULL((void*)0));
      if (indescr == NULL((void*)0)) {
          goto fail;
      }
  }
  if (max != NULL((void*)0)) {
      newdescr = PyArray_DescrFromObject(max, indescr);
      Py_XDECREF(indescr)_Py_XDECREF(((PyObject*)(indescr)));
      indescr = NULL((void*)0);
      if (newdescr == NULL((void*)0)) {
          goto fail;
      }
  }
  else {
      /* Steal the reference */
      newdescr = indescr;
      indescr = NULL((void*)0);
  }


  /*
   * Use the scalar descriptor only if it is of a bigger
   * KIND than the input array (and then find the
   * type that matches both).
   */
  if (PyArray_ScalarKind(newdescr->type_num, NULL((void*)0)) >
      PyArray_ScalarKind(PyArray_DESCR(self)->type_num, NULL((void*)0))) {
      indescr = PyArray_PromoteTypes(newdescr, PyArray_DESCR(self));
      if (indescr == NULL((void*)0)) {
          goto fail;
      }
      func = indescr->f->fastclip;
      if (func == NULL((void*)0)) {
          Py_DECREF(indescr)_Py_DECREF(((PyObject*)(indescr)));
          return _slow_array_clip(self, min, max, out);
      }
  }
  else {
      indescr = PyArray_DESCR(self);
      Py_INCREF(indescr)_Py_INCREF(((PyObject*)(indescr)));
  }
  Py_DECREF(newdescr)_Py_DECREF(((PyObject*)(newdescr)));
  newdescr = NULL((void*)0);

  if (!PyDataType_ISNOTSWAPPED(indescr)((((PyArray_Descr *)(indescr))->byteorder) != '>')) {
      PyArray_Descr *descr2;
      descr2 = PyArray_DescrNewByteorder(indescr, '=');
      Py_DECREF(indescr)_Py_DECREF(((PyObject*)(indescr)));
      indescr = NULL((void*)0);
      if (descr2 == NULL((void*)0)) {
          goto fail;
      }
      indescr = descr2;
  }

  /* Convert max to an array */
  if (max != NULL((void*)0)) {
      Py_INCREF(indescr)_Py_INCREF(((PyObject*)(indescr)));
      maxa = (PyArrayObject *)PyArray_FromAny(max, indescr, 0, 0,
                               NPY_ARRAY_DEFAULT((0x0001 | (0x0100 | 0x0400))), NULL((void*)0));
      if (maxa == NULL((void*)0)) {
          goto fail;
      }
  }

  /*
   * If we are unsigned, then make sure min is not < 0
   * This is to match the behavior of _slow_array_clip
   *
   * We allow min and max to go beyond the limits
   * for other data-types in which case they
   * are interpreted as their modular counterparts.
  */
  if (min != NULL((void*)0)) {
      if (PyArray_ISUNSIGNED(self)(((PyArray_TYPE(self)) == NPY_UBYTE) || ((PyArray_TYPE(self))
 == NPY_USHORT) || ((PyArray_TYPE(self)) == NPY_UINT) || ((PyArray_TYPE
(self)) == NPY_ULONG) || ((PyArray_TYPE(self)) == NPY_ULONGLONG
))) {
          int cmp;
          zero = PyLong_FromLong(0);
          cmp = PyObject_RichCompareBool(min, zero, Py_LT0);
          if (cmp == -1) {
              Py_DECREF(zero)_Py_DECREF(((PyObject*)(zero)));
              goto fail;
          }
          if (cmp == 1) {
              min = zero;
          }
          else {
              Py_DECREF(zero)_Py_DECREF(((PyObject*)(zero)));
              Py_INCREF(min)_Py_INCREF(((PyObject*)(min)));
          }
      }
      else {
          Py_INCREF(min)_Py_INCREF(((PyObject*)(min)));
      }

      /* Convert min to an array */
      Py_INCREF(indescr)_Py_INCREF(((PyObject*)(indescr)));
      mina = (PyArrayObject *)PyArray_FromAny(min, indescr, 0, 0,
                               NPY_ARRAY_DEFAULT((0x0001 | (0x0100 | 0x0400))), NULL((void*)0));
      Py_DECREF(min)_Py_DECREF(((PyObject*)(min)));
      if (mina == NULL((void*)0)) {
          goto fail;
      }
  }

  /*
   * Check to see if input is single-segment, aligned,
   * and in native byteorder
   */
  if (PyArray_ISONESEGMENT(self)(PyArray_CHKFLAGS(self, 0x0001) || PyArray_CHKFLAGS(self, 0x0002
)) &&
                          PyArray_CHKFLAGS(self, NPY_ARRAY_ALIGNED0x0100) &&
                          PyArray_ISNOTSWAPPED(self)((PyArray_DESCR(self)->byteorder) != '>') &&
                          (PyArray_DESCR(self) == indescr)) {
      ingood = 1;
  }
  if (!ingood) {
      int flags;

      if (PyArray_ISFORTRAN(self)(PyArray_CHKFLAGS(self, 0x0002) && (!PyArray_CHKFLAGS
(self, 0x0001)))) {
          flags = NPY_ARRAY_FARRAY(0x0002 | (0x0100 | 0x0400));
      }
      else {
          flags = NPY_ARRAY_CARRAY(0x0001 | (0x0100 | 0x0400));
      }
      Py_INCREF(indescr)_Py_INCREF(((PyObject*)(indescr)));
      newin = (PyArrayObject *)PyArray_FromArray(self, indescr, flags);
      if (newin == NULL((void*)0)) {
          goto fail;
      }
  }
  else {
      newin = self;
      Py_INCREF(newin)_Py_INCREF(((PyObject*)(newin)));
  }

  /*
   * At this point, newin is a single-segment, aligned, and correct
   * byte-order array of the correct type
   *
   * if ingood == 0, then it is a copy, otherwise,
   * it is the original input.
   */

  /*
   * If we have already made a copy of the data, then use
   * that as the output array
   */
  if (out == NULL((void*)0) && !ingood) {
      out = newin;
  }

  /*
   * Now, we know newin is a usable array for fastclip,
   * we need to make sure the output array is available
   * and usable
   */
  if (out == NULL((void*)0)) {
      Py_INCREF(indescr)_Py_INCREF(((PyObject*)(indescr)));
      out = (PyArrayObject*)PyArray_NewFromDescr(Py_TYPE(self)(((PyObject*)(self))->ob_type),
                                          indescr, PyArray_NDIM(self),
                                          PyArray_DIMS(self),
                                          NULL((void*)0), NULL((void*)0),
                                          PyArray_ISFORTRAN(self)(PyArray_CHKFLAGS(self, 0x0002) && (!PyArray_CHKFLAGS
(self, 0x0001))),
                                          (PyObject *)self);
      if (out == NULL((void*)0)) {
          goto fail;
      }

      outgood = 1;
  }
  else Py_INCREF(out)_Py_INCREF(((PyObject*)(out)));
  /* Input is good at this point */
  if (out == newin) {
      outgood = 1;
  }


  /* make sure the shape of the output array is the same */
  if (!PyArray_SAMESHAPE(newin, out)((PyArray_NDIM(newin) == PyArray_NDIM(out)) && PyArray_CompareLists
(PyArray_DIMS(newin), PyArray_DIMS(out), PyArray_NDIM(newin))
)) {
      PyErr_SetString(PyExc_ValueError, "clip: Output array must have the"
                      "same shape as the input.");
      goto fail;
  }

  if (!outgood && PyArray_EQUIVALENTLY_ITERABLE(( ( PyArray_NDIM(self) == PyArray_NDIM(out) && PyArray_CompareLists
(PyArray_DIMS(self), PyArray_DIMS(out), PyArray_NDIM(self)) &&
 (PyArray_FLAGS(self)&(0x0001| 0x0002)) & (PyArray_FLAGS
(out)&(0x0001| 0x0002)) ) && PyArray_EQUIVALENTLY_ITERABLE_OVERLAP_OK
( self, out, 1, 0))
                          self, out, PyArray_TRIVIALLY_ITERABLE_OP_READ,( ( PyArray_NDIM(self) == PyArray_NDIM(out) && PyArray_CompareLists
(PyArray_DIMS(self), PyArray_DIMS(out), PyArray_NDIM(self)) &&
 (PyArray_FLAGS(self)&(0x0001| 0x0002)) & (PyArray_FLAGS
(out)&(0x0001| 0x0002)) ) && PyArray_EQUIVALENTLY_ITERABLE_OVERLAP_OK
( self, out, 1, 0))
                          PyArray_TRIVIALLY_ITERABLE_OP_NOREAD)( ( PyArray_NDIM(self) == PyArray_NDIM(out) && PyArray_CompareLists
(PyArray_DIMS(self), PyArray_DIMS(out), PyArray_NDIM(self)) &&
 (PyArray_FLAGS(self)&(0x0001| 0x0002)) & (PyArray_FLAGS
(out)&(0x0001| 0x0002)) ) && PyArray_EQUIVALENTLY_ITERABLE_OVERLAP_OK
( self, out, 1, 0)) &&
                      PyArray_CHKFLAGS(out, NPY_ARRAY_ALIGNED0x0100) &&
                      PyArray_ISNOTSWAPPED(out)((PyArray_DESCR(out)->byteorder) != '>') &&
                      PyArray_EquivTypes(PyArray_DESCR(out), indescr)) {
      outgood = 1;
  }

  /*
   * Do we still not have a suitable output array?
   * Create one, now. No matter why the array is not suitable a copy has
   * to be made. This may be just to avoid memory overlap though.
   */
  if (!outgood) {
      int oflags;
      if (PyArray_ISFORTRAN(self)(PyArray_CHKFLAGS(self, 0x0002) && (!PyArray_CHKFLAGS
(self, 0x0001)))) {
          oflags = NPY_ARRAY_FARRAY(0x0002 | (0x0100 | 0x0400));
      }
      else {
          oflags = NPY_ARRAY_CARRAY(0x0001 | (0x0100 | 0x0400));
      }
      oflags |= (NPY_ARRAY_WRITEBACKIFCOPY0x2000 | NPY_ARRAY_FORCECAST0x0010 |
                 NPY_ARRAY_ENSURECOPY0x0020);
      Py_INCREF(indescr)_Py_INCREF(((PyObject*)(indescr)));
      newout = (PyArrayObject*)PyArray_FromArray(out, indescr, oflags);
      if (newout == NULL((void*)0)) {
          goto fail;
      }
  }
  else {
      newout = out;
      Py_INCREF(newout)_Py_INCREF(((PyObject*)(newout)));
  }

  /* Now we can call the fast-clip function */
  min_data = max_data = NULL((void*)0);
  if (mina != NULL((void*)0)) {
      min_data = PyArray_DATA(mina);
  }
  if (maxa != NULL((void*)0)) {
      max_data = PyArray_DATA(maxa);
  }
  func(PyArray_DATA(newin), PyArray_SIZE(newin)PyArray_MultiplyList(PyArray_DIMS(newin), PyArray_NDIM(newin)
), min_data, max_data, PyArray_DATA(newout));

  /* Clean up temporary variables */
  Py_XDECREF(indescr)_Py_XDECREF(((PyObject*)(indescr)));
  Py_XDECREF(newdescr)_Py_XDECREF(((PyObject*)(newdescr)));
  Py_XDECREF(mina)_Py_XDECREF(((PyObject*)(mina)));
  Py_XDECREF(maxa)_Py_XDECREF(((PyObject*)(maxa)));
  Py_DECREF(newin)_Py_DECREF(((PyObject*)(newin)));
  /* Copy back into out if out was not already a nice array. */
  PyArray_ResolveWritebackIfCopy(newout);
  Py_DECREF(newout)_Py_DECREF(((PyObject*)(newout)));
  return (PyObject *)out;

fail:
  Py_XDECREF(indescr)_Py_XDECREF(((PyObject*)(indescr)));
  Py_XDECREF(newdescr)_Py_XDECREF(((PyObject*)(newdescr)));
  Py_XDECREF(maxa)_Py_XDECREF(((PyObject*)(maxa)));
  Py_XDECREF(mina)_Py_XDECREF(((PyObject*)(mina)));
  Py_XDECREF(newin)_Py_XDECREF(((PyObject*)(newin)));
  PyArray_DiscardWritebackIfCopy(newout);
  Py_XDECREF(newout)_Py_XDECREF(((PyObject*)(newout)));
  return NULL((void*)0);
1199}


1202/*NUMPY_API
* Conjugate
*/
1205NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1206PyArray_Conjugate(PyArrayObject *self, PyArrayObject *out)
1207{
  if (PyArray_ISCOMPLEX(self)(((PyArray_TYPE(self)) >= NPY_CFLOAT) && ((PyArray_TYPE
(self)) <= NPY_CLONGDOUBLE)) || PyArray_ISOBJECT(self)((PyArray_TYPE(self)) == NPY_OBJECT) ||
          PyArray_ISUSERDEF(self)(((PyArray_TYPE(self)) >= NPY_USERDEF) && ((PyArray_TYPE
(self)) < NPY_USERDEF+ NPY_NUMUSERTYPES))) {
      if (out == NULL((void*)0)) {
          return PyArray_GenericUnaryFunction(self,
                                              n_ops.conjugate);
      }
      else {
          return PyArray_GenericBinaryFunction((PyObject *)self,
                                               (PyObject *)out,
                                               n_ops.conjugate);
      }
  }
  else {
      PyArrayObject *ret;
      if (!PyArray_ISNUMBER(self)(((PyArray_TYPE(self)) <= NPY_CLONGDOUBLE) || ((PyArray_TYPE
(self)) == NPY_HALF))) {
          /* 2017-05-04, 1.13 */
          if (DEPRECATE("attempting to conjugate non-numeric dtype; this "PyErr_WarnEx(PyExc_DeprecationWarning,"attempting to conjugate non-numeric dtype; this "
 "will error in the future to match the behavior of " "np.conjugate"
,1)
                        "will error in the future to match the behavior of "PyErr_WarnEx(PyExc_DeprecationWarning,"attempting to conjugate non-numeric dtype; this "
 "will error in the future to match the behavior of " "np.conjugate"
,1)
                        "np.conjugate")PyErr_WarnEx(PyExc_DeprecationWarning,"attempting to conjugate non-numeric dtype; this "
 "will error in the future to match the behavior of " "np.conjugate"
,1) < 0) {
              return NULL((void*)0);
          }
      }
      if (out) {
          if (PyArray_AssignArray(out, self,
                      NULL((void*)0), NPY_DEFAULT_ASSIGN_CASTING) < 0) {
              return NULL((void*)0);
          }
          ret = out;
      }
      else {
          ret = self;
      }
      Py_INCREF(ret)_Py_INCREF(((PyObject*)(ret)));
      return (PyObject *)ret;
  }
1243}

1245/*NUMPY_API
* Trace
*/
1248NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1249PyArray_Trace(PyArrayObject *self, int offset, int axis1, int axis2,
            int rtype, PyArrayObject *out)
1251{
  PyObject *diag = NULL((void*)0), *ret = NULL((void*)0);

  diag = PyArray_Diagonal(self, offset, axis1, axis2);
  if (diag == NULL((void*)0)) {
      return NULL((void*)0);
  }
  ret = PyArray_GenericReduceFunction((PyArrayObject *)diag, n_ops.add, -1, rtype, out);
  Py_DECREF(diag)_Py_DECREF(((PyObject*)(diag)));
  return ret;
1261}

←

/opt/pyrefcon/lib/pyrefcon/models/models/PyNumber_Subtract.model

→

1#ifndef PyNumber_Subtract
2struct _object;
3typedef struct _object PyObject;
4PyObject* clang_analyzer_PyObject_New_Reference();
5PyObject* PyNumber_Subtract(PyObject *o1, PyObject *o2) {
6  return clang_analyzer_PyObject_New_Reference();
11
←
Setting reference count to 1→
7}
8#else
9#warning "API PyNumber_Subtract is defined as a macro."
10#endif

←

/tmp/pyrefcon/numpy/numpy/core/src/multiarray/ctors.c

1#define PY_SSIZE_T_CLEAN
2#include <Python.h>
3#include "structmember.h"

5#define NPY_NO_DEPRECATED_API0x0000000E NPY_API_VERSION0x0000000E
6#define _MULTIARRAYMODULE
7#include "numpy/arrayobject.h"
8#include "numpy/arrayscalars.h"

10#include "numpy/npy_math.h"

12#include "npy_config.h"

14#include "npy_ctypes.h"
15#include "npy_pycompat.h"
16#include "multiarraymodule.h"

18#include "common.h"
19#include "ctors.h"
20#include "convert_datatype.h"
21#include "shape.h"
22#include "npy_buffer.h"
23#include "lowlevel_strided_loops.h"
24#include "_datetime.h"
25#include "datetime_strings.h"
26#include "array_assign.h"
27#include "mapping.h" /* for array_item_asarray */
28#include "templ_common.h" /* for npy_mul_with_overflow_intp */
29#include "alloc.h"
30#include <assert.h>

32#include "get_attr_string.h"
33#include "array_coercion.h"

35/*
* Reading from a file or a string.
*
* As much as possible, we try to use the same code for both files and strings,
* so the semantics for fromstring and fromfile are the same, especially with
* regards to the handling of text representations.
*/

43/*
* Scanning function for next element parsing and separator skipping.
* These functions return:
*   - 0 to indicate more data to read
*   - -1 when reading stopped at the end of the string/file
*   - -2 when reading stopped before the end was reached.
*
* The dtype specific parsing functions may set the python error state
* (they have to get the GIL first) additionally.
*/
53typedef int (*next_element)(void **, void *, PyArray_Descr *, void *);
54typedef int (*skip_separator)(void **, const char *, void *);


57static npy_bool
58string_is_fully_read(char const* start, char const* end) {
  if (end == NULL((void*)0)) {
      return *start == '\0';  /* null terminated */
  }
  else {
      return start >= end;  /* fixed length */
  }
65}


68static int
69fromstr_next_element(char **s, void *dptr, PyArray_Descr *dtype,
                   const char *end)
71{
  char *e = *s;
  int r = dtype->f->fromstr(*s, dptr, &e, dtype);
  /*
   * fromstr always returns 0 for basic dtypes; s points to the end of the
   * parsed string. If s is not changed an error occurred or the end was
   * reached.
   */
  if (*s == e || r < 0) {
      /* Nothing read, could be end of string or an error (or both) */
      if (string_is_fully_read(*s, end)) {
          return -1;
      }
      return -2;
  }
  *s = e;
  if (end != NULL((void*)0) && *s > end) {
      /* Stop the iteration if we read far enough */
      return -1;
  }
  return 0;
92}

94static int
95fromfile_next_element(FILE **fp, void *dptr, PyArray_Descr *dtype,
                    void *NPY_UNUSED(stream_data)(__NPY_UNUSED_TAGGEDstream_data) __attribute__ ((__unused__)))
97{
  /* the NULL argument is for backwards-compatibility */
  int r = dtype->f->scanfunc(*fp, dptr, NULL((void*)0), dtype);
  /* r can be EOF or the number of items read (0 or 1) */
  if (r == 1) {
      return 0;
  }
  else if (r == EOF(-1)) {
      return -1;
  }
  else {
      /* unable to read more, but EOF not reached indicating an error. */
      return -2;
  }
111}

113/*
* Remove multiple whitespace from the separator, and add a space to the
* beginning and end. This simplifies the separator-skipping code below.
*/
117static char *
118swab_separator(const char *sep)
119{
  int skip_space = 0;
  char *s, *start;

  s = start = malloc(strlen(sep)+3);
  if (s == NULL((void*)0)) {
      PyErr_NoMemory();
      return NULL((void*)0);
  }
  /* add space to front if there isn't one */
  if (*sep != '\0' && !isspace(*sep)((*__ctype_b_loc ())[(int) ((*sep))] & (unsigned short int
) _ISspace)) {
      *s = ' '; s++;
  }
  while (*sep != '\0') {
      if (isspace(*sep)((*__ctype_b_loc ())[(int) ((*sep))] & (unsigned short int
) _ISspace)) {
          if (skip_space) {
              sep++;
          }
          else {
              *s = ' ';
              s++;
              sep++;
              skip_space = 1;
          }
      }
      else {
          *s = *sep;
          s++;
          sep++;
          skip_space = 0;
      }
  }
  /* add space to end if there isn't one */
  if (s != start && s[-1] == ' ') {
      *s = ' ';
      s++;
  }
  *s = '\0';
  return start;
158}

160/*
* Assuming that the separator is the next bit in the string (file), skip it.
*
* Single spaces in the separator are matched to arbitrary-long sequences
* of whitespace in the input. If the separator consists only of spaces,
* it matches one or more whitespace characters.
*
* If we can't match the separator, return -2.
* If we hit the end of the string (file), return -1.
* Otherwise, return 0.
*/
171static int
172fromstr_skip_separator(char **s, const char *sep, const char *end)
173{
  char *string = *s;
  int result = 0;

  while (1) {
      char c = *string;
      if (string_is_fully_read(string, end)) {
          result = -1;
          break;
      }
      else if (*sep == '\0') {
          if (string != *s) {
              /* matched separator */
              result = 0;
              break;
          }
          else {
              /* separator was whitespace wildcard that didn't match */
              result = -2;
              break;
          }
      }
      else if (*sep == ' ') {
          /* whitespace wildcard */
          if (!isspace(c)((*__ctype_b_loc ())[(int) ((c))] & (unsigned short int) _ISspace
)) {
              sep++;
              continue;
          }
      }
      else if (*sep != c) {
          result = -2;
          break;
      }
      else {
          sep++;
      }
      string++;
  }
  *s = string;
  return result;
213}

215static int
216fromfile_skip_separator(FILE **fp, const char *sep, void *NPY_UNUSED(stream_data)(__NPY_UNUSED_TAGGEDstream_data) __attribute__ ((__unused__)))
217{
  int result = 0;
  const char *sep_start = sep;

  while (1) {
      int c = fgetc(*fp);

      if (c == EOF(-1)) {
          result = -1;
          break;
      }
      else if (*sep == '\0') {
          ungetc(c, *fp);
          if (sep != sep_start) {
              /* matched separator */
              result = 0;
              break;
          }
          else {
              /* separator was whitespace wildcard that didn't match */
              result = -2;
              break;
          }
      }
      else if (*sep == ' ') {
          /* whitespace wildcard */
          if (!isspace(c)((*__ctype_b_loc ())[(int) ((c))] & (unsigned short int) _ISspace
)) {
              sep++;
              sep_start++;
              ungetc(c, *fp);
          }
          else if (sep == sep_start) {
              sep_start--;
          }
      }
      else if (*sep != c) {
          ungetc(c, *fp);
          result = -2;
          break;
      }
      else {
          sep++;
      }
  }
  return result;
262}

264/*
* Change a sub-array field to the base descriptor
* and update the dimensions and strides
* appropriately.  Dimensions and strides are added
* to the end.
*
* Strides are only added if given (because data is given).
*/
272static int
273_update_descr_and_dimensions(PyArray_Descr **des, npy_intp *newdims,
                           npy_intp *newstrides, int oldnd)
275{
  PyArray_Descr *old;
  int newnd;
  int numnew;
  npy_intp *mydim;
  int i;
  int tuple;

  old = *des;
  *des = old->subarray->base;


  mydim = newdims + oldnd;
  tuple = PyTuple_Check(old->subarray->shape)((((((PyObject*)(old->subarray->shape))->ob_type))->
tp_flags & ((1UL << 26))) != 0);
  if (tuple) {
      numnew = PyTuple_GET_SIZE(old->subarray->shape)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(old->subarray
->shape))))->ob_size);
  }
  else {
      numnew = 1;
  }


  newnd = oldnd + numnew;
  if (newnd > NPY_MAXDIMS32) {
      goto finish;
  }
  if (tuple) {
      for (i = 0; i < numnew; i++) {
          mydim[i] = (npy_intp) PyLong_AsLong(
                  PyTuple_GET_ITEM(old->subarray->shape, i)((((void) (0)), (PyTupleObject *)(old->subarray->shape)
)->ob_item[i]));
      }
  }
  else {
      mydim[0] = (npy_intp) PyLong_AsLong(old->subarray->shape);
  }

  if (newstrides) {
      npy_intp tempsize;
      npy_intp *mystrides;

      mystrides = newstrides + oldnd;
      /* Make new strides -- always C-contiguous */
      tempsize = (*des)->elsize;
      for (i = numnew - 1; i >= 0; i--) {
          mystrides[i] = tempsize;
          tempsize *= mydim[i] ? mydim[i] : 1;
      }
  }

finish:
  Py_INCREF(*des)_Py_INCREF(((PyObject*)(*des)));
  Py_DECREF(old)_Py_DECREF(((PyObject*)(old)));
  return newnd;
328}

330NPY_NO_EXPORT__attribute__((visibility("hidden"))) void
331_unaligned_strided_byte_copy(char *dst, npy_intp outstrides, char *src,
                           npy_intp instrides, npy_intp N, int elsize)
333{
  npy_intp i;
  char *tout = dst;
  char *tin = src;

338#define _COPY_N_SIZE(size) \
  for(i=0; i<N; i++) { \
      memcpy(tout, tin, size); \
      tin += instrides; \
      tout += outstrides; \
  } \
  return

  switch(elsize) {
  case 8:
      _COPY_N_SIZE(8);
  case 4:
      _COPY_N_SIZE(4);
  case 1:
      _COPY_N_SIZE(1);
  case 2:
      _COPY_N_SIZE(2);
  case 16:
      _COPY_N_SIZE(16);
  default:
      _COPY_N_SIZE(elsize);
  }
360#undef _COPY_N_SIZE

362}

364NPY_NO_EXPORT__attribute__((visibility("hidden"))) void
365_strided_byte_swap(void *p, npy_intp stride, npy_intp n, int size)
366{
  char *a, *b, c = 0;
  int j, m;

  switch(size) {
  case 1: /* no byteswap necessary */
      break;
  case 4:
      if (npy_is_aligned((void*)((npy_intp)p | stride), sizeof(npy_uint32))) {
          for (a = (char*)p; n > 0; n--, a += stride) {
              npy_uint32 * a_ = (npy_uint32 *)a;
              *a_ = npy_bswap4(*a_);
          }
      }
      else {
          for (a = (char*)p; n > 0; n--, a += stride) {
              npy_bswap4_unaligned(a);
          }
      }
      break;
  case 8:
      if (npy_is_aligned((void*)((npy_intp)p | stride), sizeof(npy_uint64))) {
          for (a = (char*)p; n > 0; n--, a += stride) {
              npy_uint64 * a_ = (npy_uint64 *)a;
              *a_ = npy_bswap8(*a_);
          }
      }
      else {
          for (a = (char*)p; n > 0; n--, a += stride) {
              npy_bswap8_unaligned(a);
          }
      }
      break;
  case 2:
      if (npy_is_aligned((void*)((npy_intp)p | stride), sizeof(npy_uint16))) {
          for (a = (char*)p; n > 0; n--, a += stride) {
              npy_uint16 * a_ = (npy_uint16 *)a;
              *a_ = npy_bswap2(*a_);
          }
      }
      else {
          for (a = (char*)p; n > 0; n--, a += stride) {
              npy_bswap2_unaligned(a);
          }
      }
      break;
  default:
      m = size/2;
      for (a = (char *)p; n > 0; n--, a += stride - m) {
          b = a + (size - 1);
          for (j = 0; j < m; j++) {
              c=*a; *a++ = *b; *b-- = c;
          }
      }
      break;
  }
422}

424NPY_NO_EXPORT__attribute__((visibility("hidden"))) void
425byte_swap_vector(void *p, npy_intp n, int size)
426{
  _strided_byte_swap(p, (npy_intp) size, n, size);
  return;
429}

431/* If numitems > 1, then dst must be contiguous */
432NPY_NO_EXPORT__attribute__((visibility("hidden"))) void
433copy_and_swap(void *dst, void *src, int itemsize, npy_intp numitems,
            npy_intp srcstrides, int swap)
435{
  if ((numitems == 1) || (itemsize == srcstrides)) {
      memcpy(dst, src, itemsize*numitems);
  }
  else {
      npy_intp i;
      char *s1 = (char *)src;
      char *d1 = (char *)dst;

      for (i = 0; i < numitems; i++) {
          memcpy(d1, s1, itemsize);
          d1 += itemsize;
          s1 += srcstrides;
      }
  }

  if (swap) {
      byte_swap_vector(dst, numitems, itemsize);
  }
454}


457/*
* Recursive helper to assign using a coercion cache. This function
* must consume the cache depth first, just as the cache was originally
* produced.
*/
462NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
463PyArray_AssignFromCache_Recursive(
      PyArrayObject *self, const int ndim, coercion_cache_obj **cache)
465{
  /* Consume first cache element by extracting information and freeing it */
  PyObject *original_obj = (*cache)->converted_obj;
  PyObject *obj = (*cache)->arr_or_sequence;
  Py_INCREF(obj)_Py_INCREF(((PyObject*)(obj)));
  npy_bool sequence = (*cache)->sequence;
  int depth = (*cache)->depth;
  *cache = npy_unlink_coercion_cache(*cache);

  /*
   * The maximum depth is special (specifically for objects), but usually
   * unrolled in the sequence branch below.
   */
  if (NPY_UNLIKELY(depth == ndim)__builtin_expect(!!(depth == ndim), 0)) {
      /*
       * We have reached the maximum depth. We should simply assign to the
       * element in principle. There is one exception. If this is a 0-D
       * array being stored into a 0-D array (but we do not reach here then).
       */
      if (PyArray_ISOBJECT(self)((PyArray_TYPE(self)) == NPY_OBJECT)) {
          assert(ndim != 0)((void) (0));  /* guaranteed by PyArray_AssignFromCache */
          assert(PyArray_NDIM(self) == 0)((void) (0));
          Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
          return PyArray_Pack(PyArray_DESCR(self), PyArray_BYTES(self),
                              original_obj);
      }
      if (sequence) {
          /*
           * Sanity check which may be removed, the error is raised already
           * in `PyArray_DiscoverDTypeAndShape`.
           */
          assert(0)((void) (0));
          PyErr_SetString(PyExc_RuntimeError,
                  "setting an array element with a sequence");
          goto fail;
      }
      else if (original_obj != obj || !PyArray_CheckExact(obj)(((PyObject*)(obj))->ob_type == &PyArray_Type)) {
          /*
           * If the leave node is an array-like, but not a numpy array,
           * we pretend it is an arbitrary scalar.  This means that in
           * most cases (where the dtype is int or float), we will end
           * up using float(array-like), or int(array-like).  That does
           * not support general casting, but helps Quantity and masked
           * arrays, because it allows them to raise an error when
           * `__float__()` or `__int__()` is called.
           */
          Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
          return PyArray_SETITEM(self, PyArray_BYTES(self), original_obj);
      }
  }

  /* The element is either a sequence, or an array */
  if (!sequence) {
      /* Straight forward array assignment */
      assert(PyArray_Check(obj))((void) (0));
      if (PyArray_CopyInto(self, (PyArrayObject *)obj) < 0) {
          goto fail;
      }
  }
  else {
      assert(depth != ndim)((void) (0));
      npy_intp length = PySequence_LengthPySequence_Size(obj);
      if (length != PyArray_DIMS(self)[0]) {
          PyErr_SetString(PyExc_RuntimeError,
                  "Inconsistent object during array creation? "
                  "Content of sequences changed (length inconsistent).");
          goto fail;
      }

      for (npy_intp i = 0; i < length; i++) {
          PyObject *value = PySequence_Fast_GET_ITEM(obj, i)(((((((PyObject*)(obj))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) ? (((PyListObject *)(obj))->ob_item[
i]) : ((((void) (0)), (PyTupleObject *)(obj))->ob_item[i])
);

          if (*cache == NULL((void*)0) || (*cache)->converted_obj != value ||
                      (*cache)->depth != depth + 1) {
              if (ndim != depth + 1) {
                  PyErr_SetString(PyExc_RuntimeError,
                          "Inconsistent object during array creation? "
                          "Content of sequences changed (now too shallow).");
                  goto fail;
              }
              /* Straight forward assignment of elements */
              char *item;
              item = (PyArray_BYTES(self) + i * PyArray_STRIDES(self)[0]);
              if (PyArray_Pack(PyArray_DESCR(self), item, value) < 0) {
                  goto fail;
              }
          }
          else {
              PyArrayObject *view;
              view = (PyArrayObject *)array_item_asarray(self, i);
              if (view == NULL((void*)0)) {
                  goto fail;
              }
              if (PyArray_AssignFromCache_Recursive(view, ndim, cache) < 0) {
                  Py_DECREF(view)_Py_DECREF(((PyObject*)(view)));
                  goto fail;
              }
              Py_DECREF(view)_Py_DECREF(((PyObject*)(view)));
          }
      }
  }
  Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
  return 0;

fail:
  Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
  return -1;
572}


575/**
* Fills an item based on a coercion cache object. It consumes the cache
* object while doing so.
*
* @param self Array to fill.
* @param cache coercion_cache_object, will be consumed. The cache must not
*        contain a single array (must start with a sequence). The array case
*        should be handled by `PyArray_FromArray()` before.
* @return 0 on success -1 on failure.
*/
585NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
586PyArray_AssignFromCache(PyArrayObject *self, coercion_cache_obj *cache) {
  int ndim = PyArray_NDIM(self);
  /*
   * Do not support ndim == 0 now with an array in the cache.
   * The ndim == 0 is special because np.array(np.array(0), dtype=object)
   * should unpack the inner array.
   * Since the single-array case is special, it is handled previously
   * in either case.
   */
  assert(cache->sequence)((void) (0));
  assert(ndim != 0)((void) (0));  /* guaranteed if cache contains a sequence */

  if (PyArray_AssignFromCache_Recursive(self, ndim, &cache) < 0) {
      /* free the remaining cache. */
      npy_free_coercion_cache(cache);
      return -1;
  }

  /*
   * Sanity check, this is the initial call, and when it returns, the
   * cache has to be fully consumed, otherwise something is wrong.
   * NOTE: May be nicer to put into a recursion helper.
   */
  if (cache != NULL((void*)0)) {
      PyErr_SetString(PyExc_RuntimeError,
              "Inconsistent object during array creation? "
              "Content of sequences changed (cache not consumed).");
      npy_free_coercion_cache(cache);
      return -1;
  }
  return 0;
617}


620static void
621raise_memory_error(int nd, npy_intp const *dims, PyArray_Descr *descr)
622{
  static PyObject *exc_type = NULL((void*)0);

  npy_cache_import(
      "numpy.core._exceptions", "_ArrayMemoryError",
      &exc_type);
  if (exc_type == NULL((void*)0)) {
      goto fail;
  }

  PyObject *shape = PyArray_IntTupleFromIntp(nd, dims);
  if (shape == NULL((void*)0)) {
      goto fail;
  }

  /* produce an error object */
  PyObject *exc_value = PyTuple_Pack(2, shape, (PyObject *)descr);
  Py_DECREF(shape)_Py_DECREF(((PyObject*)(shape)));
  if (exc_value == NULL((void*)0)){
      goto fail;
  }
  PyErr_SetObject(exc_type, exc_value);
  Py_DECREF(exc_value)_Py_DECREF(((PyObject*)(exc_value)));
  return;

647fail:
  /* we couldn't raise the formatted exception for some reason */
  PyErr_WriteUnraisable(NULL((void*)0));
  PyErr_NoMemory();
651}

653/*
* Generic new array creation routine.
* Internal variant with calloc argument for PyArray_Zeros.
*
* steals a reference to descr. On failure or descr->subarray, descr will
* be decrefed.
*/
660NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
661PyArray_NewFromDescr_int(
      PyTypeObject *subtype, PyArray_Descr *descr, int nd,
      npy_intp const *dims, npy_intp const *strides, void *data,
      int flags, PyObject *obj, PyObject *base, int zeroed,
      int allow_emptystring)
666{
  PyArrayObject_fields *fa;
  npy_intp nbytes;

  if (nd > NPY_MAXDIMS32 || nd < 0) {
      PyErr_Format(PyExc_ValueError,
              "number of dimensions must be within [0, %d]", NPY_MAXDIMS32);
      Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
      return NULL((void*)0);
  }

  if (descr->subarray) {
      PyObject *ret;
      npy_intp newdims[2*NPY_MAXDIMS32];
      npy_intp *newstrides = NULL((void*)0);
      memcpy(newdims, dims, nd*sizeof(npy_intp));
      if (strides) {
          newstrides = newdims + NPY_MAXDIMS32;
          memcpy(newstrides, strides, nd*sizeof(npy_intp));
      }
      nd =_update_descr_and_dimensions(&descr, newdims,
                                       newstrides, nd);
      ret = PyArray_NewFromDescr_int(
              subtype, descr,
              nd, newdims, newstrides, data,
              flags, obj, base,
              zeroed, allow_emptystring);
      return ret;
  }

  /* Check datatype element size */
  nbytes = descr->elsize;
  if (PyDataType_ISUNSIZED(descr)((descr)->elsize == 0 && !(((PyArray_Descr *)(descr
))->names != ((void*)0)))) {
      if (!PyDataType_ISFLEXIBLE(descr)(((((PyArray_Descr*)(descr))->type_num) >=NPY_STRING) &&
 ((((PyArray_Descr*)(descr))->type_num) <=NPY_VOID))) {
          PyErr_SetString(PyExc_TypeError, "Empty data-type");
          Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
          return NULL((void*)0);
      }
      else if (PyDataType_ISSTRING(descr)(((((PyArray_Descr*)(descr))->type_num) == NPY_STRING) || (
(((PyArray_Descr*)(descr))->type_num) == NPY_UNICODE)) && !allow_emptystring &&
               data == NULL((void*)0)) {
          PyArray_DESCR_REPLACE(descr)do { PyArray_Descr *_new_; _new_ = PyArray_DescrNew(descr); _Py_XDECREF
(((PyObject*)(descr))); descr = _new_; } while(0);
          if (descr == NULL((void*)0)) {
              return NULL((void*)0);
          }
          if (descr->type_num == NPY_STRING) {
              nbytes = descr->elsize = 1;
          }
          else {
              nbytes = descr->elsize = sizeof(npy_ucs4);
          }
      }
  }

  fa = (PyArrayObject_fields *) subtype->tp_alloc(subtype, 0);
  if (fa == NULL((void*)0)) {
      Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
      return NULL((void*)0);
  }
  fa->_buffer_info = NULL((void*)0);
  fa->nd = nd;
  fa->dimensions = NULL((void*)0);
  fa->data = NULL((void*)0);

  if (data == NULL((void*)0)) {
      fa->flags = NPY_ARRAY_DEFAULT((0x0001 | (0x0100 | 0x0400)));
      if (flags) {
          fa->flags |= NPY_ARRAY_F_CONTIGUOUS0x0002;
          if (nd > 1) {
              fa->flags &= ~NPY_ARRAY_C_CONTIGUOUS0x0001;
          }
          flags = NPY_ARRAY_F_CONTIGUOUS0x0002;
      }
  }
  else {
      fa->flags = (flags & ~NPY_ARRAY_WRITEBACKIFCOPY0x2000);
      fa->flags &= ~NPY_ARRAY_UPDATEIFCOPY0x1000;
  }
  fa->descr = descr;
  fa->base = (PyObject *)NULL((void*)0);
  fa->weakreflist = (PyObject *)NULL((void*)0);

  if (nd > 0) {
      fa->dimensions = npy_alloc_cache_dim(2 * nd);
      if (fa->dimensions == NULL((void*)0)) {
          PyErr_NoMemory();
          goto fail;
      }
      fa->strides = fa->dimensions + nd;

      /* Copy dimensions, check them, and find total array size `nbytes` */
      for (int i = 0; i < nd; i++) {
          fa->dimensions[i] = dims[i];

          if (fa->dimensions[i] == 0) {
              /*
               * Compare to PyArray_OverflowMultiplyList that
               * returns 0 in this case.
               */
              continue;
          }

          if (fa->dimensions[i] < 0) {
              PyErr_SetString(PyExc_ValueError,
                      "negative dimensions are not allowed");
              goto fail;
          }

          /*
           * Care needs to be taken to avoid integer overflow when multiplying
           * the dimensions together to get the total size of the array.
           */
          if (npy_mul_with_overflow_intp(&nbytes, nbytes, fa->dimensions[i])) {
              PyErr_SetString(PyExc_ValueError,
                      "array is too big; `arr.size * arr.dtype.itemsize` "
                      "is larger than the maximum possible size.");
              goto fail;
          }
      }

      /* Fill the strides (or copy them if they were passed in) */
      if (strides == NULL((void*)0)) {
          /* fill the strides and set the contiguity flags */
          _array_fill_strides(fa->strides, dims, nd, descr->elsize,
                              flags, &(fa->flags));
      }
      else {
          /* User to provided strides (user is responsible for correctness) */
          for (int i = 0; i < nd; i++) {
              fa->strides[i] = strides[i];
          }
          /* Since the strides were passed in must update contiguity */
          PyArray_UpdateFlags((PyArrayObject *)fa,
                  NPY_ARRAY_C_CONTIGUOUS0x0001|NPY_ARRAY_F_CONTIGUOUS0x0002);
      }
  }
  else {
      fa->dimensions = NULL((void*)0);
      fa->strides = NULL((void*)0);
      fa->flags |= NPY_ARRAY_C_CONTIGUOUS0x0001|NPY_ARRAY_F_CONTIGUOUS0x0002;
  }

  if (data == NULL((void*)0)) {
      /*
       * Allocate something even for zero-space arrays
       * e.g. shape=(0,) -- otherwise buffer exposure
       * (a.data) doesn't work as it should.
       * Could probably just allocate a few bytes here. -- Chuck
       */
      if (nbytes == 0) {
          nbytes = descr->elsize ? descr->elsize : 1;
      }
      /*
       * It is bad to have uninitialized OBJECT pointers
       * which could also be sub-fields of a VOID array
       */
      if (zeroed || PyDataType_FLAGCHK(descr, NPY_NEEDS_INIT)(((descr)->flags & (0x08)) == (0x08))) {
          data = npy_alloc_cache_zero(nbytes);
      }
      else {
          data = npy_alloc_cache(nbytes);
      }
      if (data == NULL((void*)0)) {
          raise_memory_error(fa->nd, fa->dimensions, descr);
          goto fail;
      }
      fa->flags |= NPY_ARRAY_OWNDATA0x0004;
  }
  else {
      /*
       * If data is passed in, this object won't own it by default.
       * Caller must arrange for this to be reset if truly desired
       */
      fa->flags &= ~NPY_ARRAY_OWNDATA0x0004;
  }
  fa->data = data;

  /*
   * Always update the aligned flag.  Not owned data or input strides may
   * not be aligned. Also on some platforms (debian sparc) malloc does not
   * provide enough alignment for long double types.
   */
  PyArray_UpdateFlags((PyArrayObject *)fa, NPY_ARRAY_ALIGNED0x0100);

  /* Set the base object. It's important to do it here so that
   * __array_finalize__ below receives it
   */
  if (base != NULL((void*)0)) {
      Py_INCREF(base)_Py_INCREF(((PyObject*)(base)));
      if (PyArray_SetBaseObject((PyArrayObject *)fa, base) < 0) {
          goto fail;
      }
  }

  /*
   * call the __array_finalize__ method if a subtype was requested.
   * If obj is NULL use Py_None for the Python callback.
   */
  if (subtype != &PyArray_Type) {
      PyObject *res, *func;

      func = PyObject_GetAttr((PyObject *)fa, npy_ma_str_array_finalize);
      if (func == NULL((void*)0)) {
          goto fail;
      }
      else if (func == Py_None(&_Py_NoneStruct)) {
          Py_DECREF(func)_Py_DECREF(((PyObject*)(func)));
      }
      else {
          if (PyCapsule_CheckExact(func)((((PyObject*)(func))->ob_type) == &PyCapsule_Type)) {
              /* A C-function is stored here */
              PyArray_FinalizeFunc *cfunc;
              cfunc = PyCapsule_GetPointer(func, NULL((void*)0));
              Py_DECREF(func)_Py_DECREF(((PyObject*)(func)));
              if (cfunc == NULL((void*)0)) {
                  goto fail;
              }
              if (cfunc((PyArrayObject *)fa, obj) < 0) {
                  goto fail;
              }
          }
          else {
              if (obj == NULL((void*)0)) {
                  obj = Py_None(&_Py_NoneStruct);
              }
              res = PyObject_CallFunctionObjArgs(func, obj, NULL((void*)0));
              Py_DECREF(func)_Py_DECREF(((PyObject*)(func)));
              if (res == NULL((void*)0)) {
                  goto fail;
              }
              else {
                  Py_DECREF(res)_Py_DECREF(((PyObject*)(res)));
              }
          }
      }
  }
  return (PyObject *)fa;

fail:
  Py_DECREF(fa)_Py_DECREF(((PyObject*)(fa)));
  return NULL((void*)0);
906}


909/*NUMPY_API
* Generic new array creation routine.
*
* steals a reference to descr. On failure or when dtype->subarray is
* true, dtype will be decrefed.
*/
915NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
916PyArray_NewFromDescr(
      PyTypeObject *subtype, PyArray_Descr *descr,
      int nd, npy_intp const *dims, npy_intp const *strides, void *data,
      int flags, PyObject *obj)
920{
  return PyArray_NewFromDescrAndBase(
          subtype, descr,
          nd, dims, strides, data,
          flags, obj, NULL((void*)0));
925}

927/*
* Sets the base object using PyArray_SetBaseObject
*/
930NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
931PyArray_NewFromDescrAndBase(
      PyTypeObject *subtype, PyArray_Descr *descr,
      int nd, npy_intp const *dims, npy_intp const *strides, void *data,
      int flags, PyObject *obj, PyObject *base)
935{
  return PyArray_NewFromDescr_int(subtype, descr, nd,
                                  dims, strides, data,
                                  flags, obj, base, 0, 0);
939}

941/*
* Creates a new array with the same shape as the provided one,
* with possible memory layout order, data type and shape changes.
*
* prototype - The array the new one should be like.
* order     - NPY_CORDER - C-contiguous result.
*             NPY_FORTRANORDER - Fortran-contiguous result.
*             NPY_ANYORDER - Fortran if prototype is Fortran, C otherwise.
*             NPY_KEEPORDER - Keeps the axis ordering of prototype.
* dtype     - If not NULL, overrides the data type of the result.
* ndim      - If not -1, overrides the shape of the result.
* dims      - If ndim is not -1, overrides the shape of the result.
* subok     - If 1, use the prototype's array subtype, otherwise
*             always create a base-class array.
*
* NOTE: If dtype is not NULL, steals the dtype reference.  On failure or when
* dtype->subarray is true, dtype will be decrefed.
*/
959NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
960PyArray_NewLikeArrayWithShape(PyArrayObject *prototype, NPY_ORDER order,
                            PyArray_Descr *dtype, int ndim, npy_intp const *dims, int subok)
962{
  PyObject *ret = NULL((void*)0);

  if (ndim == -1) {
      ndim = PyArray_NDIM(prototype);
      dims = PyArray_DIMS(prototype);
  }
  else if (order == NPY_KEEPORDER && (ndim != PyArray_NDIM(prototype))) {
      order = NPY_CORDER;
  }

  /* If no override data type, use the one from the prototype */
  if (dtype == NULL((void*)0)) {
      dtype = PyArray_DESCR(prototype);
      Py_INCREF(dtype)_Py_INCREF(((PyObject*)(dtype)));
  }

  /* Handle ANYORDER and simple KEEPORDER cases */
  switch (order) {
      case NPY_ANYORDER:
          order = PyArray_ISFORTRAN(prototype)(PyArray_CHKFLAGS(prototype, 0x0002) && (!PyArray_CHKFLAGS
(prototype, 0x0001))) ?
                                  NPY_FORTRANORDER : NPY_CORDER;
          break;
      case NPY_KEEPORDER:
          if (PyArray_IS_C_CONTIGUOUS(prototype)PyArray_CHKFLAGS((prototype), 0x0001) || ndim <= 1) {
              order = NPY_CORDER;
              break;
          }
          else if (PyArray_IS_F_CONTIGUOUS(prototype)PyArray_CHKFLAGS((prototype), 0x0002)) {
              order = NPY_FORTRANORDER;
              break;
          }
          break;
      default:
          break;
  }

  /* If it's not KEEPORDER, this is simple */
  if (order != NPY_KEEPORDER) {
      ret = PyArray_NewFromDescr(subok ? Py_TYPE(prototype)(((PyObject*)(prototype))->ob_type) : &PyArray_Type,
                                      dtype,
                                      ndim,
                                      dims,
                                      NULL((void*)0),
                                      NULL((void*)0),
                                      order,
                                      subok ? (PyObject *)prototype : NULL((void*)0));
  }
  /* KEEPORDER needs some analysis of the strides */
  else {
      npy_intp strides[NPY_MAXDIMS32], stride;
      npy_stride_sort_item strideperm[NPY_MAXDIMS32];
      int idim;

      PyArray_CreateSortedStridePerm(ndim,
                                      PyArray_STRIDES(prototype),
                                      strideperm);

      /* Build the new strides */
      stride = dtype->elsize;
      for (idim = ndim-1; idim >= 0; --idim) {
          npy_intp i_perm = strideperm[idim].perm;
          strides[i_perm] = stride;
          stride *= dims[i_perm];
      }

      /* Finally, allocate the array */
      ret = PyArray_NewFromDescr(subok ? Py_TYPE(prototype)(((PyObject*)(prototype))->ob_type) : &PyArray_Type,
                                      dtype,
                                      ndim,
                                      dims,
                                      strides,
                                      NULL((void*)0),
                                      0,
                                      subok ? (PyObject *)prototype : NULL((void*)0));
  }

  return ret;
1040}

1042/*NUMPY_API
* Creates a new array with the same shape as the provided one,
* with possible memory layout order and data type changes.
*
* prototype - The array the new one should be like.
* order     - NPY_CORDER - C-contiguous result.
*             NPY_FORTRANORDER - Fortran-contiguous result.
*             NPY_ANYORDER - Fortran if prototype is Fortran, C otherwise.
*             NPY_KEEPORDER - Keeps the axis ordering of prototype.
* dtype     - If not NULL, overrides the data type of the result.
* subok     - If 1, use the prototype's array subtype, otherwise
*             always create a base-class array.
*
* NOTE: If dtype is not NULL, steals the dtype reference.  On failure or when
* dtype->subarray is true, dtype will be decrefed.
*/
1058NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1059PyArray_NewLikeArray(PyArrayObject *prototype, NPY_ORDER order,
                   PyArray_Descr *dtype, int subok)
1061{
  return PyArray_NewLikeArrayWithShape(prototype, order, dtype, -1, NULL((void*)0), subok);
1063}

1065/*NUMPY_API
* Generic new array creation routine.
*/
1068NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1069PyArray_New(
      PyTypeObject *subtype, int nd, npy_intp const *dims, int type_num,
      npy_intp const *strides, void *data, int itemsize, int flags,
      PyObject *obj)
1073{
  PyArray_Descr *descr;
  PyObject *new;

  descr = PyArray_DescrFromType(type_num);
  if (descr == NULL((void*)0)) {
      return NULL((void*)0);
  }
  if (PyDataType_ISUNSIZED(descr)((descr)->elsize == 0 && !(((PyArray_Descr *)(descr
))->names != ((void*)0)))) {
      if (itemsize < 1) {
          PyErr_SetString(PyExc_ValueError,
                          "data type must provide an itemsize");
          Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
          return NULL((void*)0);
      }
      PyArray_DESCR_REPLACE(descr)do { PyArray_Descr *_new_; _new_ = PyArray_DescrNew(descr); _Py_XDECREF
(((PyObject*)(descr))); descr = _new_; } while(0);
      descr->elsize = itemsize;
  }
  new = PyArray_NewFromDescr(subtype, descr, nd, dims, strides,
                             data, flags, obj);
  return new;
1094}


1097NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArray_Descr *
1098_dtype_from_buffer_3118(PyObject *memoryview)
1099{
  PyArray_Descr *descr;
  Py_buffer *view = PyMemoryView_GET_BUFFER(memoryview)(&((PyMemoryViewObject *)(memoryview))->view);
  if (view->format != NULL((void*)0)) {
      descr = _descriptor_from_pep3118_format(view->format);
      if (descr == NULL((void*)0)) {
          return NULL((void*)0);
      }
  }
  else {
      /* If no format is specified, just assume a byte array
       * TODO: void would make more sense here, as it wouldn't null
       *       terminate.
       */
      descr = PyArray_DescrNewFromType(NPY_STRING);
      descr->elsize = view->itemsize;
  }
  return descr;
1117}


1120NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1121_array_from_buffer_3118(PyObject *memoryview)
1122{
  /* PEP 3118 */
  Py_buffer *view;
  PyArray_Descr *descr = NULL((void*)0);
  PyObject *r = NULL((void*)0);
  int nd, flags;
  Py_ssize_t d;
  npy_intp shape[NPY_MAXDIMS32], strides[NPY_MAXDIMS32];

  view = PyMemoryView_GET_BUFFER(memoryview)(&((PyMemoryViewObject *)(memoryview))->view);
  nd = view->ndim;
  descr = _dtype_from_buffer_3118(memoryview);

  if (descr == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* Sanity check */
  if (descr->elsize != view->itemsize) {
      /* Ctypes has bugs in its PEP3118 implementation, which we need to
       * work around.
       *
       * bpo-10746
       * bpo-32780
       * bpo-32782
       *
       * Note that even if the above are fixed in main, we have to drop the
       * early patch versions of python to actually make use of the fixes.
       */
      if (!npy_ctypes_check(Py_TYPE(view->obj)(((PyObject*)(view->obj))->ob_type))) {
          /* This object has no excuse for a broken PEP3118 buffer */
          PyErr_Format(
                  PyExc_RuntimeError,
                 "Item size %zd for PEP 3118 buffer format "
                  "string %s does not match the dtype %c item size %d.",
                  view->itemsize, view->format, descr->type,
                  descr->elsize);
          Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
          return NULL((void*)0);
      }

      if (PyErr_Warn(PyErr_WarnEx(PyExc_RuntimeWarning, "A builtin ctypes object gave a PEP3118 format "
 "string that does not match its itemsize, so a " "best-guess will be made of the data type. "
 "Newer versions of python may behave correctly.", 1)
                  PyExc_RuntimeWarning,PyErr_WarnEx(PyExc_RuntimeWarning, "A builtin ctypes object gave a PEP3118 format "
 "string that does not match its itemsize, so a " "best-guess will be made of the data type. "
 "Newer versions of python may behave correctly.", 1)
                  "A builtin ctypes object gave a PEP3118 format "PyErr_WarnEx(PyExc_RuntimeWarning, "A builtin ctypes object gave a PEP3118 format "
 "string that does not match its itemsize, so a " "best-guess will be made of the data type. "
 "Newer versions of python may behave correctly.", 1)
                  "string that does not match its itemsize, so a "PyErr_WarnEx(PyExc_RuntimeWarning, "A builtin ctypes object gave a PEP3118 format "
 "string that does not match its itemsize, so a " "best-guess will be made of the data type. "
 "Newer versions of python may behave correctly.", 1)
                  "best-guess will be made of the data type. "PyErr_WarnEx(PyExc_RuntimeWarning, "A builtin ctypes object gave a PEP3118 format "
 "string that does not match its itemsize, so a " "best-guess will be made of the data type. "
 "Newer versions of python may behave correctly.", 1)
                  "Newer versions of python may behave correctly.")PyErr_WarnEx(PyExc_RuntimeWarning, "A builtin ctypes object gave a PEP3118 format "
 "string that does not match its itemsize, so a " "best-guess will be made of the data type. "
 "Newer versions of python may behave correctly.", 1) < 0) {
          Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
          return NULL((void*)0);
      }

      /* Thankfully, np.dtype(ctypes_type) works in most cases.
       * For an array input, this produces a dtype containing all the
       * dimensions, so the array is now 0d.
       */
      nd = 0;
      Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
      descr = (PyArray_Descr *)PyObject_CallFunctionObjArgs(
              (PyObject *)&PyArrayDescr_Type(*(PyTypeObject *)(&PyArrayDescr_TypeFull)), Py_TYPE(view->obj)(((PyObject*)(view->obj))->ob_type), NULL((void*)0));
      if (descr == NULL((void*)0)) {
          return NULL((void*)0);
      }
      if (descr->elsize != view->len) {
          PyErr_SetString(
                  PyExc_RuntimeError,
                  "For the given ctypes object, neither the item size "
                  "computed from the PEP 3118 buffer format nor from "
                  "converting the type to a np.dtype matched the actual "
                  "size. This is a bug both in python and numpy");
          Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
          return NULL((void*)0);
      }
  }

  if (view->shape != NULL((void*)0)) {
      int k;
      if (nd > NPY_MAXDIMS32 || nd < 0) {
          PyErr_Format(PyExc_RuntimeError,
              "PEP3118 dimensions do not satisfy 0 <= ndim <= NPY_MAXDIMS");
          goto fail;
      }
      for (k = 0; k < nd; ++k) {
          shape[k] = view->shape[k];
      }
      if (view->strides != NULL((void*)0)) {
          for (k = 0; k < nd; ++k) {
              strides[k] = view->strides[k];
          }
      }
      else {
          d = view->len;
          for (k = 0; k < nd; ++k) {
              if (view->shape[k] != 0) {
                  d /= view->shape[k];
              }
              strides[k] = d;
          }
      }
  }
  else {
      if (nd == 1) {
          shape[0] = view->len / view->itemsize;
          strides[0] = view->itemsize;
      }
      else if (nd > 1) {
          PyErr_SetString(PyExc_RuntimeError,
                         "ndim computed from the PEP 3118 buffer format "
                         "is greater than 1, but shape is NULL.");
          goto fail;
      }
  }

  flags = NPY_ARRAY_BEHAVED(0x0100 | 0x0400) & (view->readonly ? ~NPY_ARRAY_WRITEABLE0x0400 : ~0);
  r = PyArray_NewFromDescrAndBase(
          &PyArray_Type, descr,
          nd, shape, strides, view->buf,
          flags, NULL((void*)0), memoryview);
  return r;


1242fail:
  Py_XDECREF(r)_Py_XDECREF(((PyObject*)(r)));
  Py_XDECREF(descr)_Py_XDECREF(((PyObject*)(descr)));
  return NULL((void*)0);

1247}


1250/**
* Attempts to extract an array from an array-like object.
*
* array-like is defined as either
*
* * an object implementing the PEP 3118 buffer interface;
* * an object with __array_struct__ or __array_interface__ attributes;
* * an object with an __array__ function.
*
* @param op The object to convert to an array
* @param requested_type a requested dtype instance, may be NULL; The result
*                       DType may be used, but is not enforced.
* @param writeable whether the result must be writeable.
* @param context Unused parameter, must be NULL (should be removed later).
*
* @returns The array object, Py_NotImplemented if op is not array-like,
*          or NULL with an error set. (A new reference to Py_NotImplemented
*          is returned.)
*/
1269NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1270_array_from_array_like(PyObject *op,
      PyArray_Descr *requested_dtype, npy_bool writeable, PyObject *context) {
  PyObject* tmp;

  /*
   * If op supports the PEP 3118 buffer interface.
   * We skip bytes and unicode since they are considered scalars. Unicode
   * would fail but bytes would be incorrectly converted to a uint8 array.
   */
  if (!PyBytes_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1UL <<
 27))) != 0) && !PyUnicode_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1UL <<
 28))) != 0)) {
      PyObject *memoryview = PyMemoryView_FromObject(op);
      if (memoryview == NULL((void*)0)) {
          PyErr_Clear();
      }
      else {
          tmp = _array_from_buffer_3118(memoryview);
          Py_DECREF(memoryview)_Py_DECREF(((PyObject*)(memoryview)));
          if (tmp == NULL((void*)0)) {
              return NULL((void*)0);
          }

          if (writeable
              && PyArray_FailUnlessWriteable(
                      (PyArrayObject *)tmp, "PEP 3118 buffer") < 0) {
              Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
              return NULL((void*)0);
          }

          return tmp;
      }
  }

  /*
   * If op supports the __array_struct__ or __array_interface__ interface.
   */
  tmp = PyArray_FromStructInterface(op);
  if (tmp == NULL((void*)0)) {
      return NULL((void*)0);
  }
  if (tmp == Py_NotImplemented(&_Py_NotImplementedStruct)) {
      /* Until the return, NotImplemented is always a borrowed reference*/
      tmp = PyArray_FromInterface(op);
      if (tmp == NULL((void*)0)) {
          return NULL((void*)0);
      }
  }

  /*
   * If op supplies the __array__ function.
   * The documentation says this should produce a copy, so
   * we skip this method if writeable is true, because the intent
   * of writeable is to modify the operand.
   * XXX: If the implementation is wrong, and/or if actual
   *      usage requires this behave differently,
   *      this should be changed!
   */
  if (!writeable && tmp == Py_NotImplemented(&_Py_NotImplementedStruct)) {
      tmp = PyArray_FromArrayAttr(op, requested_dtype, context);
      if (tmp == NULL((void*)0)) {
          return NULL((void*)0);
      }
  }

  if (tmp != Py_NotImplemented(&_Py_NotImplementedStruct)) {
      if (writeable &&
              PyArray_FailUnlessWriteable((PyArrayObject *)tmp,
                      "array interface object") < 0) {
          Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
          return NULL((void*)0);
      }
      return tmp;
  }

  /* Until here Py_NotImplemented was borrowed */
  Py_INCREF(Py_NotImplemented)_Py_INCREF(((PyObject*)((&_Py_NotImplementedStruct))));
  return Py_NotImplemented(&_Py_NotImplementedStruct);
1346}


1349/*NUMPY_API*/
1350NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
1351PyArray_GetArrayParamsFromObject(PyObject *NPY_UNUSED(op)(__NPY_UNUSED_TAGGEDop) __attribute__ ((__unused__)),
      PyArray_Descr *NPY_UNUSED(requested_dtype)(__NPY_UNUSED_TAGGEDrequested_dtype) __attribute__ ((__unused__
)),
      npy_bool NPY_UNUSED(writeable)(__NPY_UNUSED_TAGGEDwriteable) __attribute__ ((__unused__)),
      PyArray_Descr **NPY_UNUSED(out_dtype)(__NPY_UNUSED_TAGGEDout_dtype) __attribute__ ((__unused__)),
      int *NPY_UNUSED(out_ndim)(__NPY_UNUSED_TAGGEDout_ndim) __attribute__ ((__unused__)), npy_intp *NPY_UNUSED(out_dims)(__NPY_UNUSED_TAGGEDout_dims) __attribute__ ((__unused__)),
      PyArrayObject **NPY_UNUSED(out_arr)(__NPY_UNUSED_TAGGEDout_arr) __attribute__ ((__unused__)), PyObject *NPY_UNUSED(context)(__NPY_UNUSED_TAGGEDcontext) __attribute__ ((__unused__)))
1357{
  /* Deprecated in NumPy 1.19, removed in NumPy 1.20. */
  PyErr_SetString(PyExc_RuntimeError,
          "PyArray_GetArrayParamsFromObject() C-API function is removed "
          "`PyArray_FromAny()` should be used at this time.  New C-API "
          "may be exposed in the future (please do request this if it "
          "would help you).");
  return -1;
1365}


1368/*
* This function is a legacy implementation to retain subarray dtype
* behaviour in array coercion. The behaviour here makes sense if tuples
* of matching dimensionality are being coerced. Due to the difficulty
* that the result is ill-defined for lists of array-likes, this is deprecated.
*
* WARNING: Do not use this function, it exists purely to support a deprecated
*          code path.
*/
1377static int
1378setArrayFromSequence(PyArrayObject *a, PyObject *s,
                      int dim, PyArrayObject * dst)
1380{
  Py_ssize_t i, slen;
  int res = -1;

  /* first recursion, view equal destination */
  if (dst == NULL((void*)0))
      dst = a;

  /*
   * This code is to ensure that the sequence access below will
   * return a lower-dimensional sequence.
   */

  /* INCREF on entry DECREF on exit */
  Py_INCREF(s)_Py_INCREF(((PyObject*)(s)));

  PyObject *seq = NULL((void*)0);

  if (PyArray_Check(s)((((PyObject*)(s))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(s))->ob_type), (&PyArray_Type)))) {
      if (!(PyArray_CheckExact(s)(((PyObject*)(s))->ob_type == &PyArray_Type))) {
          /*
           * make sure a base-class array is used so that the dimensionality
           * reduction assumption is correct.
           */
          /* This will DECREF(s) if replaced */
          s = PyArray_EnsureArray(s);
          if (s == NULL((void*)0)) {
              goto fail;
          }
      }

      /* dst points to correct array subsection */
      if (PyArray_CopyInto(dst, (PyArrayObject *)s) < 0) {
          goto fail;
      }

      Py_DECREF(s)_Py_DECREF(((PyObject*)(s)));
      return 0;
  }

  if (dim > PyArray_NDIM(a)) {
      PyErr_Format(PyExc_ValueError,
               "setArrayFromSequence: sequence/array dimensions mismatch.");
      goto fail;
  }

  /* Try __array__ before using s as a sequence */
  PyObject *tmp = _array_from_array_like(s, NULL((void*)0), 0, NULL((void*)0));
  if (tmp == NULL((void*)0)) {
      goto fail;
  }
  else if (tmp == Py_NotImplemented(&_Py_NotImplementedStruct)) {
      Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
  }
  else {
      int r = PyArray_CopyInto(dst, (PyArrayObject *)tmp);
      Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
      if (r < 0) {
          goto fail;
      }
      Py_DECREF(s)_Py_DECREF(((PyObject*)(s)));
      return 0;
  }

  seq = PySequence_Fast(s, "Could not convert object to sequence");
  if (seq == NULL((void*)0)) {
      goto fail;
  }
  slen = PySequence_Fast_GET_SIZE(seq)(((((((PyObject*)(seq))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) ? (((void) (0)), (((PyVarObject*)(seq))
->ob_size)) : (((PyVarObject*)((((void) (0)), (PyTupleObject
 *)(seq))))->ob_size));

  /*
   * Either the dimensions match, or the sequence has length 1 and can
   * be broadcast to the destination.
   */
  if (slen != PyArray_DIMS(a)[dim] && slen != 1) {
      PyErr_Format(PyExc_ValueError,
               "cannot copy sequence with size %zd to array axis "
               "with dimension %" NPY_INTP_FMT"ld", slen, PyArray_DIMS(a)[dim]);
      goto fail;
  }

  /* Broadcast the one element from the sequence to all the outputs */
  if (slen == 1) {
      PyObject *o = PySequence_Fast_GET_ITEM(seq, 0)(((((((PyObject*)(seq))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) ? (((PyListObject *)(seq))->ob_item[
0]) : ((((void) (0)), (PyTupleObject *)(seq))->ob_item[0])
);
      npy_intp alen = PyArray_DIM(a, dim);

      for (i = 0; i < alen; i++) {
          if ((PyArray_NDIM(a) - dim) > 1) {
              PyArrayObject * tmp =
                  (PyArrayObject *)array_item_asarray(dst, i);
              if (tmp == NULL((void*)0)) {
                  goto fail;
              }

              res = setArrayFromSequence(a, o, dim+1, tmp);
              Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
          }
          else {
              char * b = (PyArray_BYTES(dst) + i * PyArray_STRIDES(dst)[0]);
              res = PyArray_SETITEM(dst, b, o);
          }
          if (res < 0) {
              goto fail;
          }
      }
  }
  /* Copy element by element */
  else {
      for (i = 0; i < slen; i++) {
          PyObject * o = PySequence_Fast_GET_ITEM(seq, i)(((((((PyObject*)(seq))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) ? (((PyListObject *)(seq))->ob_item[
i]) : ((((void) (0)), (PyTupleObject *)(seq))->ob_item[i])
);
          if ((PyArray_NDIM(a) - dim) > 1) {
              PyArrayObject * tmp =
                  (PyArrayObject *)array_item_asarray(dst, i);
              if (tmp == NULL((void*)0)) {
                  goto fail;
              }

              res = setArrayFromSequence(a, o, dim+1, tmp);
              Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
          }
          else {
              char * b = (PyArray_BYTES(dst) + i * PyArray_STRIDES(dst)[0]);
              res = PyArray_SETITEM(dst, b, o);
          }
          if (res < 0) {
              goto fail;
          }
      }
  }

  Py_DECREF(seq)_Py_DECREF(((PyObject*)(seq)));
  Py_DECREF(s)_Py_DECREF(((PyObject*)(s)));
  return 0;

fail:
  Py_XDECREF(seq)_Py_XDECREF(((PyObject*)(seq)));
  Py_DECREF(s)_Py_DECREF(((PyObject*)(s)));
  return res;
1518}



1522/*NUMPY_API
* Does not check for NPY_ARRAY_ENSURECOPY and NPY_ARRAY_NOTSWAPPED in flags
* Steals a reference to newtype --- which can be NULL
*/
1526NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1527PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth,
              int max_depth, int flags, PyObject *context)
1529{
  /*
   * This is the main code to make a NumPy array from a Python
   * Object.  It is called from many different places.
   */
  PyArrayObject *arr = NULL((void*)0), *ret;
  PyArray_Descr *dtype = NULL((void*)0);
  coercion_cache_obj *cache = NULL((void*)0);
  int ndim = 0;
  npy_intp dims[NPY_MAXDIMS32];

  if (context != NULL((void*)0)) {
      PyErr_SetString(PyExc_RuntimeError, "'context' must be NULL");
      return NULL((void*)0);
  }

  PyArray_Descr *fixed_descriptor;
  PyArray_DTypeMeta *fixed_DType;
  if (PyArray_ExtractDTypeAndDescriptor((PyObject *)newtype,
          &fixed_descriptor, &fixed_DType) < 0) {
      Py_XDECREF(newtype)_Py_XDECREF(((PyObject*)(newtype)));
      return NULL((void*)0);
  }
  Py_XDECREF(newtype)_Py_XDECREF(((PyObject*)(newtype)));

  ndim = PyArray_DiscoverDTypeAndShape(op,
          NPY_MAXDIMS32, dims, &cache, fixed_DType, fixed_descriptor, &dtype);

  Py_XDECREF(fixed_descriptor)_Py_XDECREF(((PyObject*)(fixed_descriptor)));
  Py_XDECREF(fixed_DType)_Py_XDECREF(((PyObject*)(fixed_DType)));
  if (ndim < 0) {
      return NULL((void*)0);
  }

  if (NPY_UNLIKELY(fixed_descriptor != NULL && PyDataType_HASSUBARRAY(dtype))__builtin_expect(!!(fixed_descriptor != ((void*)0) &&
 ((dtype)->subarray != ((void*)0))), 0)) {
      /*
       * When a subarray dtype was passed in, its dimensions are appended
       * to the array dimension (causing a dimension mismatch).
       * There is a problem with that, because if we coerce from non-arrays
       * we do this correctly by element (as defined by tuples), but for
       * arrays we first append the dimensions and then assign to the base
       * dtype and then assign which causes the problem.
       *
       * Thus, we check if there is an array included, in that case we
       * give a FutureWarning.
       * When the warning is removed, PyArray_Pack will have to ensure
       * that that it does not append the dimensions when creating the
       * subarrays to assign `arr[0] = obj[0]`.
       */
      int includes_array = 0;
      if (cache != NULL((void*)0)) {
          /* This is not ideal, but it is a pretty special case */
          coercion_cache_obj *next = cache;
          while (next != NULL((void*)0)) {
              if (!next->sequence) {
                  includes_array = 1;
                  break;
              }
              next = next->next;
          }
      }
      if (includes_array) {
          npy_free_coercion_cache(cache);

          ret = (PyArrayObject *) PyArray_NewFromDescr(
                  &PyArray_Type, dtype, ndim, dims, NULL((void*)0), NULL((void*)0),
                  flags & NPY_ARRAY_F_CONTIGUOUS0x0002, NULL((void*)0));
          if (ret == NULL((void*)0)) {
              return NULL((void*)0);
          }
          assert(PyArray_NDIM(ret) != ndim)((void) (0));

          /* NumPy 1.20, 2020-10-01 */
          if (DEPRECATE_FUTUREWARNING(PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "creating an array with a subarray dtype will behave "PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "differently when the `np.array()` (or `asarray`, etc.) "PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "call includes an array or array object.\n"PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "If you are converting a single array or a list of arrays,"PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "you can opt-in to the future behaviour using:\n"PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n"PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "\n"PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "By including a new field and indexing it after the "PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "conversion.\n"PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "This may lead to a different result or to current failures "PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1)
                  "succeeding.  (FutureWarning since NumPy 1.20)")PyErr_WarnEx(PyExc_FutureWarning,"creating an array with a subarray dtype will behave "
 "differently when the `np.array()` (or `asarray`, etc.) " "call includes an array or array object.\n"
 "If you are converting a single array or a list of arrays," "you can opt-in to the future behaviour using:\n"
 "    np.array(arr, dtype=np.dtype(['f', dtype]))['f']\n" "    np.array([arr1, arr2], dtype=np.dtype(['f', dtype]))['f']\n"
 "\n" "By including a new field and indexing it after the " "conversion.\n"
 "This may lead to a different result or to current failures "
 "succeeding.  (FutureWarning since NumPy 1.20)",1) < 0) {
              Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
              return NULL((void*)0);
          }

          if (setArrayFromSequence(ret, op, 0, NULL((void*)0)) < 0) {
              Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
              return NULL((void*)0);
          }
          return (PyObject *)ret;
      }
  }

  if (dtype == NULL((void*)0)) {
      dtype = PyArray_DescrFromType(NPY_DEFAULT_TYPENPY_DOUBLE);
  }

  if (min_depth != 0 && ndim < min_depth) {
      PyErr_SetString(PyExc_ValueError,
              "object of too small depth for desired array");
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
      npy_free_coercion_cache(cache);
      return NULL((void*)0);
  }
  if (max_depth != 0 && ndim > max_depth) {
      PyErr_SetString(PyExc_ValueError,
              "object too deep for desired array");
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
      npy_free_coercion_cache(cache);
      return NULL((void*)0);
  }

  /* Got the correct parameters, but the cache may already hold the result */
  if (cache != NULL((void*)0) && !(cache->sequence)) {
      /*
       * There is only a single array-like and it was converted, it
       * may still have the incorrect type, but that is handled below.
       */
      assert(cache->converted_obj == op)((void) (0));
      arr = (PyArrayObject *)(cache->arr_or_sequence);
      /* we may need to cast or assert flags (e.g. copy) */
      PyObject *res = PyArray_FromArray(arr, dtype, flags);
      npy_unlink_coercion_cache(cache);
      return res;
  }
  else if (cache == NULL((void*)0) && PyArray_IsScalar(op, Void)(((((PyObject*)(op))->ob_type) == (&PyVoidArrType_Type
) || PyType_IsSubtype((((PyObject*)(op))->ob_type), (&
PyVoidArrType_Type)))) &&
          !(((PyVoidScalarObject *)op)->flags & NPY_ARRAY_OWNDATA0x0004) &&
          newtype == NULL((void*)0)) {
      /*
       * Special case, we return a *view* into void scalars, mainly to
       * allow things similar to the "reversed" assignment:
       *    arr[indx]["field"] = val  # instead of arr["field"][indx] = val
       *
       * It is unclear that this is necessary in this particular code path.
       * Note that this path is only activated when the user did _not_
       * provide a dtype (newtype is NULL).
       */
      assert(ndim == 0)((void) (0));

      return PyArray_NewFromDescrAndBase(
              &PyArray_Type, dtype,
              0, NULL((void*)0), NULL((void*)0),
              ((PyVoidScalarObject *)op)->obval,
              ((PyVoidScalarObject *)op)->flags,
              NULL((void*)0), op);
  }
  else if (cache == 0 && newtype != NULL((void*)0) &&
          PyDataType_ISSIGNED(newtype)(((((PyArray_Descr*)(newtype))->type_num) == NPY_BYTE) || (
(((PyArray_Descr*)(newtype))->type_num) == NPY_SHORT) || (
(((PyArray_Descr*)(newtype))->type_num) == NPY_INT) || (((
(PyArray_Descr*)(newtype))->type_num) == NPY_LONG) || ((((
PyArray_Descr*)(newtype))->type_num) == NPY_LONGLONG)) && PyArray_IsScalar(op, Generic)(((((PyObject*)(op))->ob_type) == (&PyGenericArrType_Type
) || PyType_IsSubtype((((PyObject*)(op))->ob_type), (&
PyGenericArrType_Type))))) {
      assert(ndim == 0)((void) (0));
      /*
       * This is an (possible) inconsistency where:
       *
       *     np.array(np.float64(np.nan), dtype=np.int64)
       *
       * behaves differently from:
       *
       *     np.array([np.float64(np.nan)], dtype=np.int64)
       *     arr1d_int64[0] = np.float64(np.nan)
       *     np.array(np.array(np.nan), dtype=np.int64)
       *
       * by not raising an error instead of using typical casting.
       * The error is desirable, but to always error seems like a
       * larger change to be considered at some other time and it is
       * undesirable that 0-D arrays behave differently from scalars.
       * This retains the behaviour, largely due to issues in pandas
       * which relied on a try/except (although hopefully that will
       * have a better solution at some point):
       * https://github.com/pandas-dev/pandas/issues/35481
       */
      return PyArray_FromScalar(op, dtype);
  }

  /* There was no array (or array-like) passed in directly. */
  if ((flags & NPY_ARRAY_WRITEBACKIFCOPY0x2000) ||
          (flags & NPY_ARRAY_UPDATEIFCOPY0x1000)) {
      PyErr_SetString(PyExc_TypeError,
                      "WRITEBACKIFCOPY used for non-array input.");
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
      npy_free_coercion_cache(cache);
      return NULL((void*)0);
  }

  /* Create a new array and copy the data */
  Py_INCREF(dtype)_Py_INCREF(((PyObject*)(dtype)));  /* hold on in case of a subarray that is replaced */
  ret = (PyArrayObject *)PyArray_NewFromDescr(
          &PyArray_Type, dtype, ndim, dims, NULL((void*)0), NULL((void*)0),
          flags&NPY_ARRAY_F_CONTIGUOUS0x0002, NULL((void*)0));
  if (ret == NULL((void*)0)) {
      npy_free_coercion_cache(cache);
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
      return NULL((void*)0);
  }
  if (ndim == PyArray_NDIM(ret)) {
      /*
       * Appending of dimensions did not occur, so use the actual dtype
       * below. This is relevant for S0 or U0 which can be replaced with
       * S1 or U1, although that should likely change.
       */
      Py_SETREF(dtype, PyArray_DESCR(ret))do { PyObject *_py_tmp = ((PyObject*)(dtype)); (dtype) = (PyArray_DESCR
(ret)); _Py_DECREF(((PyObject*)(_py_tmp))); } while (0);
      Py_INCREF(dtype)_Py_INCREF(((PyObject*)(dtype)));
  }

  if (cache == NULL((void*)0)) {
      /* This is a single item. Set it directly. */
      assert(ndim == 0)((void) (0));

      if (PyArray_Pack(dtype, PyArray_BYTES(ret), op) < 0) {
          Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return NULL((void*)0);
      }
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
      return (PyObject *)ret;
  }
  assert(ndim != 0)((void) (0));
  assert(op == cache->converted_obj)((void) (0));

  /* Decrease the number of dimensions to the detected ones */
  int out_ndim = PyArray_NDIM(ret);
  PyArray_Descr *out_descr = PyArray_DESCR(ret);
  ((PyArrayObject_fields *)ret)->nd = ndim;
  ((PyArrayObject_fields *)ret)->descr = dtype;

  int success = PyArray_AssignFromCache(ret, cache);

  ((PyArrayObject_fields *)ret)->nd = out_ndim;
  ((PyArrayObject_fields *)ret)->descr = out_descr;
  Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
  if (success < 0) {
      Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
      return NULL((void*)0);
  }
  return (PyObject *)ret;
1767}

1769/*
* flags is any of
* NPY_ARRAY_C_CONTIGUOUS (formerly CONTIGUOUS),
* NPY_ARRAY_F_CONTIGUOUS (formerly FORTRAN),
* NPY_ARRAY_ALIGNED,
* NPY_ARRAY_WRITEABLE,
* NPY_ARRAY_NOTSWAPPED,
* NPY_ARRAY_ENSURECOPY,
* NPY_ARRAY_UPDATEIFCOPY,
* NPY_ARRAY_WRITEBACKIFCOPY,
* NPY_ARRAY_FORCECAST,
* NPY_ARRAY_ENSUREARRAY,
* NPY_ARRAY_ELEMENTSTRIDES
*
* or'd (|) together
*
* Any of these flags present means that the returned array should
* guarantee that aspect of the array.  Otherwise the returned array
* won't guarantee it -- it will depend on the object as to whether or
* not it has such features.
*
* Note that NPY_ARRAY_ENSURECOPY is enough
* to guarantee NPY_ARRAY_C_CONTIGUOUS, NPY_ARRAY_ALIGNED and
* NPY_ARRAY_WRITEABLE and therefore it is redundant to include
* those as well.
*
* NPY_ARRAY_BEHAVED == NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE
* NPY_ARRAY_CARRAY = NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_BEHAVED
* NPY_ARRAY_FARRAY = NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_BEHAVED
*
* NPY_ARRAY_F_CONTIGUOUS can be set in the FLAGS to request a FORTRAN array.
* Fortran arrays are always behaved (aligned,
* notswapped, and writeable) and not (C) CONTIGUOUS (if > 1d).
*
* NPY_ARRAY_UPDATEIFCOPY is deprecated in favor of
* NPY_ARRAY_WRITEBACKIFCOPY in 1.14

* NPY_ARRAY_WRITEBACKIFCOPY flag sets this flag in the returned
* array if a copy is made and the base argument points to the (possibly)
* misbehaved array. Before returning to python, PyArray_ResolveWritebackIfCopy
* must be called to update the contents of the original array from the copy.
*
* NPY_ARRAY_FORCECAST will cause a cast to occur regardless of whether or not
* it is safe.
*
* context is passed through to PyArray_GetArrayParamsFromObject
*/

1817/*NUMPY_API
* steals a reference to descr -- accepts NULL
*/
1820NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1821PyArray_CheckFromAny(PyObject *op, PyArray_Descr *descr, int min_depth,
                   int max_depth, int requires, PyObject *context)
1823{
  PyObject *obj;
  if (requires & NPY_ARRAY_NOTSWAPPED0x0200) {
      if (!descr && PyArray_Check(op)((((PyObject*)(op))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(op))->ob_type), (&PyArray_Type))) &&
              PyArray_ISBYTESWAPPED((PyArrayObject* )op)(!((PyArray_DESCR((PyArrayObject* )op)->byteorder) != '>'
))) {
          descr = PyArray_DescrNew(PyArray_DESCR((PyArrayObject *)op));
      }
      else if (descr && !PyArray_ISNBO(descr->byteorder)((descr->byteorder) != '>')) {
          PyArray_DESCR_REPLACE(descr)do { PyArray_Descr *_new_; _new_ = PyArray_DescrNew(descr); _Py_XDECREF
(((PyObject*)(descr))); descr = _new_; } while(0);
      }
      if (descr && descr->byteorder != NPY_IGNORE'|') {
          descr->byteorder = NPY_NATIVE'=';
      }
  }

  obj = PyArray_FromAny(op, descr, min_depth, max_depth, requires, context);
  if (obj == NULL((void*)0)) {
      return NULL((void*)0);
  }
  if ((requires & NPY_ARRAY_ELEMENTSTRIDES0x0080) &&
      !PyArray_ElementStrides(obj)) {
      PyObject *ret;
      ret = PyArray_NewCopy((PyArrayObject *)obj, NPY_ANYORDER);
      Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
      obj = ret;
  }
  return obj;
1850}


1853/*NUMPY_API
* steals reference to newtype --- acc. NULL
*/
1856NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
1857PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags)
1858{

  PyArrayObject *ret = NULL((void*)0);
  int copy = 0;
  int arrflags;
  PyArray_Descr *oldtype;
  NPY_CASTING casting = NPY_SAFE_CASTING;

  oldtype = PyArray_DESCR(arr);
  if (newtype == NULL((void*)0)) {
      /*
       * Check if object is of array with Null newtype.
       * If so return it directly instead of checking for casting.
       */
      if (flags == 0) {
          Py_INCREF(arr)_Py_INCREF(((PyObject*)(arr)));
          return (PyObject *)arr;
      }
      newtype = oldtype;
      Py_INCREF(oldtype)_Py_INCREF(((PyObject*)(oldtype)));
  }
  else if (PyDataType_ISUNSIZED(newtype)((newtype)->elsize == 0 && !(((PyArray_Descr *)(newtype
))->names != ((void*)0)))) {
      PyArray_DESCR_REPLACE(newtype)do { PyArray_Descr *_new_; _new_ = PyArray_DescrNew(newtype);
 _Py_XDECREF(((PyObject*)(newtype))); newtype = _new_; } while
(0);
      if (newtype == NULL((void*)0)) {
          return NULL((void*)0);
      }
      newtype->elsize = oldtype->elsize;
  }

  /* If the casting if forced, use the 'unsafe' casting rule */
  if (flags & NPY_ARRAY_FORCECAST0x0010) {
      casting = NPY_UNSAFE_CASTING;
  }

  /* Raise an error if the casting rule isn't followed */
  if (!PyArray_CanCastArrayTo(arr, newtype, casting)) {
      PyErr_Clear();
      npy_set_invalid_cast_error(
              PyArray_DESCR(arr), newtype, casting, PyArray_NDIM(arr) == 0);
      Py_DECREF(newtype)_Py_DECREF(((PyObject*)(newtype)));
      return NULL((void*)0);
  }

  arrflags = PyArray_FLAGS(arr);
         /* If a guaranteed copy was requested */
  copy = (flags & NPY_ARRAY_ENSURECOPY0x0020) ||
         /* If C contiguous was requested, and arr is not */
         ((flags & NPY_ARRAY_C_CONTIGUOUS0x0001) &&
                 (!(arrflags & NPY_ARRAY_C_CONTIGUOUS0x0001))) ||
         /* If an aligned array was requested, and arr is not */
         ((flags & NPY_ARRAY_ALIGNED0x0100) &&
                 (!(arrflags & NPY_ARRAY_ALIGNED0x0100))) ||
         /* If a Fortran contiguous array was requested, and arr is not */
         ((flags & NPY_ARRAY_F_CONTIGUOUS0x0002) &&
                 (!(arrflags & NPY_ARRAY_F_CONTIGUOUS0x0002))) ||
         /* If a writeable array was requested, and arr is not */
         ((flags & NPY_ARRAY_WRITEABLE0x0400) &&
                 (!(arrflags & NPY_ARRAY_WRITEABLE0x0400))) ||
         !PyArray_EquivTypes(oldtype, newtype);

  if (copy) {
      NPY_ORDER order = NPY_KEEPORDER;
      int subok = 1;

      /* Set the order for the copy being made based on the flags */
      if (flags & NPY_ARRAY_F_CONTIGUOUS0x0002) {
          order = NPY_FORTRANORDER;
      }
      else if (flags & NPY_ARRAY_C_CONTIGUOUS0x0001) {
          order = NPY_CORDER;
      }

      if ((flags & NPY_ARRAY_ENSUREARRAY0x0040)) {
          subok = 0;
      }
      ret = (PyArrayObject *)PyArray_NewLikeArray(arr, order,
                                                  newtype, subok);
      if (ret == NULL((void*)0)) {
          return NULL((void*)0);
      }

      if (PyArray_CopyInto(ret, arr) < 0) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return NULL((void*)0);
      }

      if (flags & NPY_ARRAY_UPDATEIFCOPY0x1000) {
          /* This is the ONLY place the NPY_ARRAY_UPDATEIFCOPY flag
           * is still used.
           * Can be deleted once the flag itself is removed
           */

          /* 2017-Nov-10 1.14 */
          if (DEPRECATE(PyErr_WarnEx(PyExc_DeprecationWarning,"NPY_ARRAY_UPDATEIFCOPY, NPY_ARRAY_INOUT_ARRAY, and "
 "NPY_ARRAY_INOUT_FARRAY are deprecated, use NPY_WRITEBACKIFCOPY, "
 "NPY_ARRAY_INOUT_ARRAY2, or NPY_ARRAY_INOUT_FARRAY2 respectively "
 "instead, and call PyArray_ResolveWritebackIfCopy before the "
 "array is deallocated, i.e. before the last call to Py_DECREF."
,1)
                  "NPY_ARRAY_UPDATEIFCOPY, NPY_ARRAY_INOUT_ARRAY, and "PyErr_WarnEx(PyExc_DeprecationWarning,"NPY_ARRAY_UPDATEIFCOPY, NPY_ARRAY_INOUT_ARRAY, and "
 "NPY_ARRAY_INOUT_FARRAY are deprecated, use NPY_WRITEBACKIFCOPY, "
 "NPY_ARRAY_INOUT_ARRAY2, or NPY_ARRAY_INOUT_FARRAY2 respectively "
 "instead, and call PyArray_ResolveWritebackIfCopy before the "
 "array is deallocated, i.e. before the last call to Py_DECREF."
,1)
                  "NPY_ARRAY_INOUT_FARRAY are deprecated, use NPY_WRITEBACKIFCOPY, "PyErr_WarnEx(PyExc_DeprecationWarning,"NPY_ARRAY_UPDATEIFCOPY, NPY_ARRAY_INOUT_ARRAY, and "
 "NPY_ARRAY_INOUT_FARRAY are deprecated, use NPY_WRITEBACKIFCOPY, "
 "NPY_ARRAY_INOUT_ARRAY2, or NPY_ARRAY_INOUT_FARRAY2 respectively "
 "instead, and call PyArray_ResolveWritebackIfCopy before the "
 "array is deallocated, i.e. before the last call to Py_DECREF."
,1)
                  "NPY_ARRAY_INOUT_ARRAY2, or NPY_ARRAY_INOUT_FARRAY2 respectively "PyErr_WarnEx(PyExc_DeprecationWarning,"NPY_ARRAY_UPDATEIFCOPY, NPY_ARRAY_INOUT_ARRAY, and "
 "NPY_ARRAY_INOUT_FARRAY are deprecated, use NPY_WRITEBACKIFCOPY, "
 "NPY_ARRAY_INOUT_ARRAY2, or NPY_ARRAY_INOUT_FARRAY2 respectively "
 "instead, and call PyArray_ResolveWritebackIfCopy before the "
 "array is deallocated, i.e. before the last call to Py_DECREF."
,1)
                  "instead, and call PyArray_ResolveWritebackIfCopy before the "PyErr_WarnEx(PyExc_DeprecationWarning,"NPY_ARRAY_UPDATEIFCOPY, NPY_ARRAY_INOUT_ARRAY, and "
 "NPY_ARRAY_INOUT_FARRAY are deprecated, use NPY_WRITEBACKIFCOPY, "
 "NPY_ARRAY_INOUT_ARRAY2, or NPY_ARRAY_INOUT_FARRAY2 respectively "
 "instead, and call PyArray_ResolveWritebackIfCopy before the "
 "array is deallocated, i.e. before the last call to Py_DECREF."
,1)
                  "array is deallocated, i.e. before the last call to Py_DECREF.")PyErr_WarnEx(PyExc_DeprecationWarning,"NPY_ARRAY_UPDATEIFCOPY, NPY_ARRAY_INOUT_ARRAY, and "
 "NPY_ARRAY_INOUT_FARRAY are deprecated, use NPY_WRITEBACKIFCOPY, "
 "NPY_ARRAY_INOUT_ARRAY2, or NPY_ARRAY_INOUT_FARRAY2 respectively "
 "instead, and call PyArray_ResolveWritebackIfCopy before the "
 "array is deallocated, i.e. before the last call to Py_DECREF."
,1) < 0) {
              Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
              return NULL((void*)0);
          }
          Py_INCREF(arr)_Py_INCREF(((PyObject*)(arr)));
          if (PyArray_SetWritebackIfCopyBase(ret, arr) < 0) {
              Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
              return NULL((void*)0);
          }
          PyArray_ENABLEFLAGS(ret, NPY_ARRAY_UPDATEIFCOPY0x1000);
          PyArray_CLEARFLAGS(ret, NPY_ARRAY_WRITEBACKIFCOPY0x2000);
      }
      else if (flags & NPY_ARRAY_WRITEBACKIFCOPY0x2000) {
          Py_INCREF(arr)_Py_INCREF(((PyObject*)(arr)));
          if (PyArray_SetWritebackIfCopyBase(ret, arr) < 0) {
              Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
              return NULL((void*)0);
          }
      }
  }
  /*
   * If no copy then take an appropriate view if necessary, or
   * just return a reference to ret itself.
   */
  else {
      int needview = ((flags & NPY_ARRAY_ENSUREARRAY0x0040) &&
                      !PyArray_CheckExact(arr)(((PyObject*)(arr))->ob_type == &PyArray_Type));

      Py_DECREF(newtype)_Py_DECREF(((PyObject*)(newtype)));
      if (needview) {
          PyTypeObject *subtype = NULL((void*)0);

          if (flags & NPY_ARRAY_ENSUREARRAY0x0040) {
              subtype = &PyArray_Type;
          }

          ret = (PyArrayObject *)PyArray_View(arr, NULL((void*)0), subtype);
          if (ret == NULL((void*)0)) {
              return NULL((void*)0);
          }
      }
      else {
          Py_INCREF(arr)_Py_INCREF(((PyObject*)(arr)));
          ret = arr;
      }
  }

  return (PyObject *)ret;
2004}

2006/*NUMPY_API */
2007NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2008PyArray_FromStructInterface(PyObject *input)
2009{
  PyArray_Descr *thetype = NULL((void*)0);
  PyArrayInterface *inter;
  PyObject *attr;
  char endian = NPY_NATBYTE'<';

  attr = PyArray_LookupSpecial_OnInstance(input, "__array_struct__");
  if (attr == NULL((void*)0)) {
      if (PyErr_Occurred()) {
          return NULL((void*)0);
      } else {
          return Py_NotImplemented(&_Py_NotImplementedStruct);
      }
  }
  if (!PyCapsule_CheckExact(attr)((((PyObject*)(attr))->ob_type) == &PyCapsule_Type)) {
      if (PyType_Check(input)((((((PyObject*)(input))->ob_type))->tp_flags & ((1UL
 << 31))) != 0) && PyObject_HasAttrString(attr, "__get__")) {
          /*
           * If the input is a class `attr` should be a property-like object.
           * This cannot be interpreted as an array, but is a valid.
           * (Needed due to the lookup being on the instance rather than type)
           */
          Py_DECREF(attr)_Py_DECREF(((PyObject*)(attr)));
          return Py_NotImplemented(&_Py_NotImplementedStruct);
      }
      goto fail;
  }
  inter = PyCapsule_GetPointer(attr, NULL((void*)0));
  if (inter == NULL((void*)0)) {
      goto fail;
  }
  if (inter->two != 2) {
      goto fail;
  }
  if ((inter->flags & NPY_ARRAY_NOTSWAPPED0x0200) != NPY_ARRAY_NOTSWAPPED0x0200) {
      endian = NPY_OPPBYTE'>';
      inter->flags &= ~NPY_ARRAY_NOTSWAPPED0x0200;
  }

  if (inter->flags & NPY_ARR_HAS_DESCR0x0800) {
      if (PyArray_DescrConverter(inter->descr, &thetype) == NPY_FAIL0) {
          thetype = NULL((void*)0);
          PyErr_Clear();
      }
  }

  if (thetype == NULL((void*)0)) {
      PyObject *type_str = PyUnicode_FromFormat(
          "%c%c%d", endian, inter->typekind, inter->itemsize);
      if (type_str == NULL((void*)0)) {
          Py_DECREF(attr)_Py_DECREF(((PyObject*)(attr)));
          return NULL((void*)0);
      }
      int ok = PyArray_DescrConverter(type_str, &thetype);
      Py_DECREF(type_str)_Py_DECREF(((PyObject*)(type_str)));
      if (ok != NPY_SUCCEED1) {
          Py_DECREF(attr)_Py_DECREF(((PyObject*)(attr)));
          return NULL((void*)0);
      }
  }

  PyObject *ret = PyArray_NewFromDescrAndBase(
          &PyArray_Type, thetype,
          inter->nd, inter->shape, inter->strides, inter->data,
          inter->flags, NULL((void*)0), input);
  Py_DECREF(attr)_Py_DECREF(((PyObject*)(attr)));
  return ret;

fail:
  PyErr_SetString(PyExc_ValueError, "invalid __array_struct__");
  Py_DECREF(attr)_Py_DECREF(((PyObject*)(attr)));
  return NULL((void*)0);
2080}

2082/*
* Checks if the object in descr is the default 'descr' member for the
* __array_interface__ dictionary with 'typestr' member typestr.
*/
2086NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
2087_is_default_descr(PyObject *descr, PyObject *typestr) {
  if (!PyList_Check(descr)((((((PyObject*)(descr))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) || PyList_GET_SIZE(descr)(((void) (0)), (((PyVarObject*)(descr))->ob_size)) != 1) {
      return 0;
  }
  PyObject *tuple = PyList_GET_ITEM(descr, 0)(((PyListObject *)(descr))->ob_item[0]);
  if (!(PyTuple_Check(tuple)((((((PyObject*)(tuple))->ob_type))->tp_flags & ((1UL
 << 26))) != 0) && PyTuple_GET_SIZE(tuple)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(tuple))))->
ob_size) == 2)) {
      return 0;
  }
  PyObject *name = PyTuple_GET_ITEM(tuple, 0)((((void) (0)), (PyTupleObject *)(tuple))->ob_item[0]);
  if (!(PyUnicode_Check(name)((((((PyObject*)(name))->ob_type))->tp_flags & ((1UL
 << 28))) != 0) && PyUnicode_GetLength(name) == 0)) {
      return 0;
  }
  PyObject *typestr2 = PyTuple_GET_ITEM(tuple, 1)((((void) (0)), (PyTupleObject *)(tuple))->ob_item[1]);
  return PyObject_RichCompareBool(typestr, typestr2, Py_EQ2);
2101}


2104/*
* A helper function to transition away from ignoring errors during
* special attribute lookups during array coercion.
*/
2108static NPY_INLINEinline int
2109deprecated_lookup_error_clearing(PyTypeObject *type, char *attribute)
2110{
  PyObject *exc_type, *exc_value, *traceback;
  PyErr_Fetch(&exc_type, &exc_value, &traceback);

  /* DEPRECATED 2021-05-12, NumPy 1.21. */
  int res = PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
          "An exception was ignored while fetching the attribute `%s` from "
          "an object of type '%s'.  With the exception of `AttributeError` "
          "NumPy will always raise this exception in the future.  Raise this "
          "deprecation warning to see the original exception. "
          "(Warning added NumPy 1.21)", attribute, type->tp_name);

  if (res < 0) {
      npy_PyErr_ChainExceptionsCause(exc_type, exc_value, traceback);
      return -1;
  }
  else {
      /* `PyErr_Fetch` cleared the original error, delete the references */
      Py_DECREF(exc_type)_Py_DECREF(((PyObject*)(exc_type)));
      Py_XDECREF(exc_value)_Py_XDECREF(((PyObject*)(exc_value)));
      Py_XDECREF(traceback)_Py_XDECREF(((PyObject*)(traceback)));
      return 0;
  }
2133}


2136/*NUMPY_API*/
2137NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2138PyArray_FromInterface(PyObject *origin)
2139{
  PyObject *iface = NULL((void*)0);
  PyObject *attr = NULL((void*)0);
  PyObject *base = NULL((void*)0);
  PyArrayObject *ret;
  PyArray_Descr *dtype = NULL((void*)0);
  char *data = NULL((void*)0);
  Py_buffer view;
  int i, n;
  npy_intp dims[NPY_MAXDIMS32], strides[NPY_MAXDIMS32];
  int dataflags = NPY_ARRAY_BEHAVED(0x0100 | 0x0400);

  iface = PyArray_LookupSpecial_OnInstance(origin, "__array_interface__");

  if (iface == NULL((void*)0)) {
      if (PyErr_Occurred()) {
          if (PyErr_ExceptionMatches(PyExc_RecursionError) ||
                  PyErr_ExceptionMatches(PyExc_MemoryError)) {
              /* RecursionError and MemoryError are considered fatal */
              return NULL((void*)0);
          }
          if (deprecated_lookup_error_clearing(
                  Py_TYPE(origin)(((PyObject*)(origin))->ob_type), "__array_interface__") < 0) {
              return NULL((void*)0);
          }
      }
      return Py_NotImplemented(&_Py_NotImplementedStruct);
  }
  if (!PyDict_Check(iface)((((((PyObject*)(iface))->ob_type))->tp_flags & ((1UL
 << 29))) != 0)) {
      if (PyType_Check(origin)((((((PyObject*)(origin))->ob_type))->tp_flags & ((
1UL << 31))) != 0) && PyObject_HasAttrString(iface, "__get__")) {
          /*
           * If the input is a class `iface` should be a property-like object.
           * This cannot be interpreted as an array, but is a valid.
           * (Needed due to the lookup being on the instance rather than type)
           */
          Py_DECREF(iface)_Py_DECREF(((PyObject*)(iface)));
          return Py_NotImplemented(&_Py_NotImplementedStruct);
      }

      Py_DECREF(iface)_Py_DECREF(((PyObject*)(iface)));
      PyErr_SetString(PyExc_ValueError,
              "Invalid __array_interface__ value, must be a dict");
      return NULL((void*)0);
  }

  /* Get type string from interface specification */
  attr = _PyDict_GetItemStringWithError(iface, "typestr");
  if (attr == NULL((void*)0)) {
      Py_DECREF(iface)_Py_DECREF(((PyObject*)(iface)));
      if (!PyErr_Occurred()) {
          PyErr_SetString(PyExc_ValueError,
                  "Missing __array_interface__ typestr");
      }
      return NULL((void*)0);
  }

  /* allow bytes for backwards compatibility */
  if (!PyBytes_Check(attr)((((((PyObject*)(attr))->ob_type))->tp_flags & ((1UL
 << 27))) != 0) && !PyUnicode_Check(attr)((((((PyObject*)(attr))->ob_type))->tp_flags & ((1UL
 << 28))) != 0)) {
      PyErr_SetString(PyExc_TypeError,
                  "__array_interface__ typestr must be a string");
      goto fail;
  }

  /* Get dtype from type string */
  if (PyArray_DescrConverter(attr, &dtype) != NPY_SUCCEED1) {
      goto fail;
  }

  /*
   * If the dtype is NPY_VOID, see if there is extra information in
   * the 'descr' attribute.
   */
  if (dtype->type_num == NPY_VOID) {
      PyObject *descr = _PyDict_GetItemStringWithError(iface, "descr");
      if (descr == NULL((void*)0) && PyErr_Occurred()) {
          goto fail;
      }
      PyArray_Descr *new_dtype = NULL((void*)0);
      if (descr != NULL((void*)0)) {
          int is_default = _is_default_descr(descr, attr);
          if (is_default < 0) {
              goto fail;
          }
          if (!is_default) {
              if (PyArray_DescrConverter2(descr, &new_dtype) != NPY_SUCCEED1) {
                  goto fail;
              }
              if (new_dtype != NULL((void*)0)) {
                  Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
                  dtype = new_dtype;
              }
          }

      }

  }

  /* Get shape tuple from interface specification */
  attr = _PyDict_GetItemStringWithError(iface, "shape");
  if (attr == NULL((void*)0)) {
      if (PyErr_Occurred()) {
          return NULL((void*)0);
      }
      /* Shape must be specified when 'data' is specified */
      PyObject *data = _PyDict_GetItemStringWithError(iface, "data");
      if (data == NULL((void*)0) && PyErr_Occurred()) {
          return NULL((void*)0);
      }
      else if (data != NULL((void*)0)) {
          Py_DECREF(iface)_Py_DECREF(((PyObject*)(iface)));
          PyErr_SetString(PyExc_ValueError,
                  "Missing __array_interface__ shape");
          return NULL((void*)0);
      }
      /* Assume shape as scalar otherwise */
      else {
          /* NOTE: pointers to data and base should be NULL */
          n = dims[0] = 0;
      }
  }
  /* Make sure 'shape' is a tuple */
  else if (!PyTuple_Check(attr)((((((PyObject*)(attr))->ob_type))->tp_flags & ((1UL
 << 26))) != 0)) {
      PyErr_SetString(PyExc_TypeError,
              "shape must be a tuple");
      goto fail;
  }
  /* Get dimensions from shape tuple */
  else {
      n = PyTuple_GET_SIZE(attr)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(attr))))->
ob_size);
      for (i = 0; i < n; i++) {
          PyObject *tmp = PyTuple_GET_ITEM(attr, i)((((void) (0)), (PyTupleObject *)(attr))->ob_item[i]);
          dims[i] = PyArray_PyIntAsIntp(tmp);
          if (error_converting(dims[i])(((dims[i]) == -1) && PyErr_Occurred())) {
              goto fail;
          }
      }
  }

  /* Get data buffer from interface specification */
  attr = _PyDict_GetItemStringWithError(iface, "data");
  if (attr == NULL((void*)0) && PyErr_Occurred()){
      return NULL((void*)0);
  }

  /* Case for data access through pointer */
  if (attr && PyTuple_Check(attr)((((((PyObject*)(attr))->ob_type))->tp_flags & ((1UL
 << 26))) != 0)) {
      PyObject *dataptr;
      if (PyTuple_GET_SIZE(attr)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(attr))))->
ob_size) != 2) {
          PyErr_SetString(PyExc_TypeError,
                  "__array_interface__ data must be a 2-tuple with "
                  "(data pointer integer, read-only flag)");
          goto fail;
      }
      dataptr = PyTuple_GET_ITEM(attr, 0)((((void) (0)), (PyTupleObject *)(attr))->ob_item[0]);
      if (PyLong_Check(dataptr)((((((PyObject*)(dataptr))->ob_type))->tp_flags & (
(1UL << 24))) != 0)) {
          data = PyLong_AsVoidPtr(dataptr);
          if (data == NULL((void*)0) && PyErr_Occurred()) {
              goto fail;
          }
      }
      else {
          PyErr_SetString(PyExc_TypeError,
                  "first element of __array_interface__ data tuple "
                  "must be an integer.");
          goto fail;
      }
      if (PyObject_IsTrue(PyTuple_GET_ITEM(attr,1)((((void) (0)), (PyTupleObject *)(attr))->ob_item[1]))) {
          dataflags &= ~NPY_ARRAY_WRITEABLE0x0400;
      }
      base = origin;
  }

  /* Case for data access through buffer */
  else if (attr) {
      if (attr != Py_None(&_Py_NoneStruct)) {
          base = attr;
      }
      else {
          base = origin;
      }
      if (PyObject_GetBuffer(base, &view,
                  PyBUF_WRITABLE0x0001|PyBUF_SIMPLE0) < 0) {
          PyErr_Clear();
          if (PyObject_GetBuffer(base, &view,
                      PyBUF_SIMPLE0) < 0) {
              goto fail;
          }
          dataflags &= ~NPY_ARRAY_WRITEABLE0x0400;
      }
      data = (char *)view.buf;
      /*
       * In Python 3 both of the deprecated functions PyObject_AsWriteBuffer and
       * PyObject_AsReadBuffer that this code replaces release the buffer. It is
       * up to the object that supplies the buffer to guarantee that the buffer
       * sticks around after the release.
       */
      PyBuffer_Release(&view);

      /* Get offset number from interface specification */
      attr = _PyDict_GetItemStringWithError(iface, "offset");
      if (attr == NULL((void*)0) && PyErr_Occurred()) {
          goto fail;
      }
      else if (attr) {
          npy_longlong num = PyLong_AsLongLong(attr);
          if (error_converting(num)(((num) == -1) && PyErr_Occurred())) {
              PyErr_SetString(PyExc_TypeError,
                      "__array_interface__ offset must be an integer");
              goto fail;
          }
          data += num;
      }
  }

  ret = (PyArrayObject *)PyArray_NewFromDescrAndBase(
          &PyArray_Type, dtype,
          n, dims, NULL((void*)0), data,
          dataflags, NULL((void*)0), base);
  /*
   * Ref to dtype was stolen by PyArray_NewFromDescrAndBase
   * Prevent DECREFing dtype in fail codepath by setting to NULL
   */
  dtype = NULL((void*)0);
  if (ret == NULL((void*)0)) {
      goto fail;
  }
  if (data == NULL((void*)0)) {
      if (PyArray_SIZE(ret)PyArray_MultiplyList(PyArray_DIMS(ret), PyArray_NDIM(ret)) > 1) {
          PyErr_SetString(PyExc_ValueError,
                  "cannot coerce scalar to array with size > 1");
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          goto fail;
      }
      if (PyArray_SETITEM(ret, PyArray_DATA(ret), origin) < 0) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          goto fail;
      }
  }
  attr = _PyDict_GetItemStringWithError(iface, "strides");
  if (attr == NULL((void*)0) && PyErr_Occurred()){
      return NULL((void*)0);
  }
  if (attr != NULL((void*)0) && attr != Py_None(&_Py_NoneStruct)) {
      if (!PyTuple_Check(attr)((((((PyObject*)(attr))->ob_type))->tp_flags & ((1UL
 << 26))) != 0)) {
          PyErr_SetString(PyExc_TypeError,
                  "strides must be a tuple");
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          goto fail;
      }
      if (n != PyTuple_GET_SIZE(attr)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(attr))))->
ob_size)) {
          PyErr_SetString(PyExc_ValueError,
                  "mismatch in length of strides and shape");
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          goto fail;
      }
      for (i = 0; i < n; i++) {
          PyObject *tmp = PyTuple_GET_ITEM(attr, i)((((void) (0)), (PyTupleObject *)(attr))->ob_item[i]);
          strides[i] = PyArray_PyIntAsIntp(tmp);
          if (error_converting(strides[i])(((strides[i]) == -1) && PyErr_Occurred())) {
              Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
              goto fail;
          }
      }
      if (n) {
          memcpy(PyArray_STRIDES(ret), strides, n*sizeof(npy_intp));
      }
  }
  PyArray_UpdateFlags(ret, NPY_ARRAY_UPDATE_ALL(0x0001 | 0x0002 | 0x0100));
  Py_DECREF(iface)_Py_DECREF(((PyObject*)(iface)));
  return (PyObject *)ret;

fail:
  Py_XDECREF(dtype)_Py_XDECREF(((PyObject*)(dtype)));
  Py_XDECREF(iface)_Py_XDECREF(((PyObject*)(iface)));
  return NULL((void*)0);
2414}

2416/*NUMPY_API
*/
2418NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2419PyArray_FromArrayAttr(PyObject *op, PyArray_Descr *typecode, PyObject *context)
2420{
  PyObject *new;
  PyObject *array_meth;

  if (context != NULL((void*)0)) {
      PyErr_SetString(PyExc_RuntimeError, "'context' must be NULL");
      return NULL((void*)0);
  }
  array_meth = PyArray_LookupSpecial_OnInstance(op, "__array__");
  if (array_meth == NULL((void*)0)) {
      if (PyErr_Occurred()) {
          if (PyErr_ExceptionMatches(PyExc_RecursionError) ||
              PyErr_ExceptionMatches(PyExc_MemoryError)) {
              /* RecursionError and MemoryError are considered fatal */
              return NULL((void*)0);
          }
          if (deprecated_lookup_error_clearing(
                  Py_TYPE(op)(((PyObject*)(op))->ob_type), "__array__") < 0) {
              return NULL((void*)0);
          }
      }
      return Py_NotImplemented(&_Py_NotImplementedStruct);
  }
  if (PyType_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1UL <<
 31))) != 0) && PyObject_HasAttrString(array_meth, "__get__")) {
      /*
       * If the input is a class `array_meth` may be a property-like object.
       * This cannot be interpreted as an array (called), but is a valid.
       * Trying `array_meth.__call__()` on this should not be useful.
       * (Needed due to the lookup being on the instance rather than type)
       */
      Py_DECREF(array_meth)_Py_DECREF(((PyObject*)(array_meth)));
      return Py_NotImplemented(&_Py_NotImplementedStruct);
  }
  if (typecode == NULL((void*)0)) {
      new = PyObject_CallFunction_PyObject_CallFunction_SizeT(array_meth, NULL((void*)0));
  }
  else {
      new = PyObject_CallFunction_PyObject_CallFunction_SizeT(array_meth, "O", typecode);
  }
  Py_DECREF(array_meth)_Py_DECREF(((PyObject*)(array_meth)));
  if (new == NULL((void*)0)) {
      return NULL((void*)0);
  }
  if (!PyArray_Check(new)((((PyObject*)(new))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(new))->ob_type), (&PyArray_Type)))) {
      PyErr_SetString(PyExc_ValueError,
                      "object __array__ method not "  \
                      "producing an array");
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      return NULL((void*)0);
  }
  return new;
2471}

2473/*NUMPY_API
2474* new reference -- accepts NULL for mintype
2475*/
2476NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArray_Descr *
2477PyArray_DescrFromObject(PyObject *op, PyArray_Descr *mintype)
2478{
  PyArray_Descr *dtype;

  dtype = mintype;
  Py_XINCREF(dtype)_Py_XINCREF(((PyObject*)(dtype)));

  if (PyArray_DTypeFromObject(op, NPY_MAXDIMS32, &dtype) < 0) {
      return NULL((void*)0);
  }

  if (dtype == NULL((void*)0)) {
      return PyArray_DescrFromType(NPY_DEFAULT_TYPENPY_DOUBLE);
  }
  else {
      return dtype;
  }
2494}

2496/* These are also old calls (should use PyArray_NewFromDescr) */

2498/* They all zero-out the memory as previously done */

2500/* steals reference to descr -- and enforces native byteorder on it.*/

2502/*NUMPY_API
Deprecated, use PyArray_NewFromDescr instead.
2504*/
2505NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2506PyArray_FromDimsAndDataAndDescr(int NPY_UNUSED(nd)(__NPY_UNUSED_TAGGEDnd) __attribute__ ((__unused__)), int *NPY_UNUSED(d)(__NPY_UNUSED_TAGGEDd) __attribute__ ((__unused__)),
                              PyArray_Descr *descr,
                              char *NPY_UNUSED(data)(__NPY_UNUSED_TAGGEDdata) __attribute__ ((__unused__)))
2509{
  PyErr_SetString(PyExc_NotImplementedError,
              "PyArray_FromDimsAndDataAndDescr: use PyArray_NewFromDescr.");
  Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
  return NULL((void*)0);
2514}

2516/*NUMPY_API
Deprecated, use PyArray_SimpleNew instead.
2518*/
2519NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2520PyArray_FromDims(int NPY_UNUSED(nd)(__NPY_UNUSED_TAGGEDnd) __attribute__ ((__unused__)), int *NPY_UNUSED(d)(__NPY_UNUSED_TAGGEDd) __attribute__ ((__unused__)), int NPY_UNUSED(type)(__NPY_UNUSED_TAGGEDtype) __attribute__ ((__unused__)))
2521{
  PyErr_SetString(PyExc_NotImplementedError,
              "PyArray_FromDims: use PyArray_SimpleNew.");
  return NULL((void*)0);
2525}

2527/* end old calls */

2529/*NUMPY_API
* This is a quick wrapper around
* PyArray_FromAny(op, NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL)
* that special cases Arrays and PyArray_Scalars up front
* It *steals a reference* to the object
* It also guarantees that the result is PyArray_Type
* Because it decrefs op if any conversion needs to take place
* so it can be used like PyArray_EnsureArray(some_function(...))
*/
2538NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2539PyArray_EnsureArray(PyObject *op)
2540{
  PyObject *new;

  if ((op == NULL((void*)0)) || (PyArray_CheckExact(op)(((PyObject*)(op))->ob_type == &PyArray_Type))) {
      new = op;
      Py_XINCREF(new)_Py_XINCREF(((PyObject*)(new)));
  }
  else if (PyArray_Check(op)((((PyObject*)(op))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(op))->ob_type), (&PyArray_Type)))) {
      new = PyArray_View((PyArrayObject *)op, NULL((void*)0), &PyArray_Type);
  }
  else if (PyArray_IsScalar(op, Generic)(((((PyObject*)(op))->ob_type) == (&PyGenericArrType_Type
) || PyType_IsSubtype((((PyObject*)(op))->ob_type), (&
PyGenericArrType_Type))))) {
      new = PyArray_FromScalar(op, NULL((void*)0));
  }
  else {
      new = PyArray_FROM_OF(op, NPY_ARRAY_ENSUREARRAY)PyArray_CheckFromAny(op, ((void*)0), 0, 0, 0x0040, ((void*)0)
);
  }
  Py_XDECREF(op)_Py_XDECREF(((PyObject*)(op)));
  return new;
2558}

2560/*NUMPY_API*/
2561NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2562PyArray_EnsureAnyArray(PyObject *op)
2563{
  if (op && PyArray_Check(op)((((PyObject*)(op))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(op))->ob_type), (&PyArray_Type)))) {
14
←
Assuming 'op' is non-null→
15
←
Assuming the condition is true→
      return op;
  }
  return PyArray_EnsureArray(op);
2568}

2570/*
* Private implementation of PyArray_CopyAnyInto with an additional order
* parameter.
*/
2574NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
2575PyArray_CopyAsFlat(PyArrayObject *dst, PyArrayObject *src, NPY_ORDER order)
2576{
  NpyIter *dst_iter, *src_iter;

  NpyIter_IterNextFunc *dst_iternext, *src_iternext;
  char **dst_dataptr, **src_dataptr;
  npy_intp dst_stride, src_stride;
  npy_intp *dst_countptr, *src_countptr;
  npy_uint32 baseflags;

  npy_intp dst_count, src_count, count;
  npy_intp dst_size, src_size;
  int needs_api;

  NPY_BEGIN_THREADS_DEFPyThreadState *_save=((void*)0);;

  if (PyArray_FailUnlessWriteable(dst, "destination array") < 0) {
      return -1;
  }

  /*
   * If the shapes match and a particular order is forced
   * for both, use the more efficient CopyInto
   */
  if (order != NPY_ANYORDER && order != NPY_KEEPORDER &&
          PyArray_NDIM(dst) == PyArray_NDIM(src) &&
          PyArray_CompareLists(PyArray_DIMS(dst), PyArray_DIMS(src),
                              PyArray_NDIM(dst))) {
      return PyArray_CopyInto(dst, src);
  }

  dst_size = PyArray_SIZE(dst)PyArray_MultiplyList(PyArray_DIMS(dst), PyArray_NDIM(dst));
  src_size = PyArray_SIZE(src)PyArray_MultiplyList(PyArray_DIMS(src), PyArray_NDIM(src));
  if (dst_size != src_size) {
      PyErr_Format(PyExc_ValueError,
              "cannot copy from array of size %" NPY_INTP_FMT"ld" " into an array "
              "of size %" NPY_INTP_FMT"ld", src_size, dst_size);
      return -1;
  }

  /* Zero-sized arrays require nothing be done */
  if (dst_size == 0) {
      return 0;
  }

  baseflags = NPY_ITER_EXTERNAL_LOOP0x00000008 |
              NPY_ITER_DONT_NEGATE_STRIDES0x00001000 |
              NPY_ITER_REFS_OK0x00000020;

  /*
   * This copy is based on matching C-order traversals of src and dst.
   * By using two iterators, we can find maximal sub-chunks that
   * can be processed at once.
   */
  dst_iter = NpyIter_New(dst, NPY_ITER_WRITEONLY0x00040000 | baseflags,
                              order,
                              NPY_NO_CASTING,
                              NULL((void*)0));
  if (dst_iter == NULL((void*)0)) {
      return -1;
  }
  src_iter = NpyIter_New(src, NPY_ITER_READONLY0x00020000 | baseflags,
                              order,
                              NPY_NO_CASTING,
                              NULL((void*)0));
  if (src_iter == NULL((void*)0)) {
      NpyIter_Deallocate(dst_iter);
      return -1;
  }

  /* Get all the values needed for the inner loop */
  dst_iternext = NpyIter_GetIterNext(dst_iter, NULL((void*)0));
  dst_dataptr = NpyIter_GetDataPtrArray(dst_iter);
  /* Since buffering is disabled, we can cache the stride */
  dst_stride = NpyIter_GetInnerStrideArray(dst_iter)[0];
  dst_countptr = NpyIter_GetInnerLoopSizePtr(dst_iter);

  src_iternext = NpyIter_GetIterNext(src_iter, NULL((void*)0));
  src_dataptr = NpyIter_GetDataPtrArray(src_iter);
  /* Since buffering is disabled, we can cache the stride */
  src_stride = NpyIter_GetInnerStrideArray(src_iter)[0];
  src_countptr = NpyIter_GetInnerLoopSizePtr(src_iter);

  if (dst_iternext == NULL((void*)0) || src_iternext == NULL((void*)0)) {
      NpyIter_Deallocate(dst_iter);
      NpyIter_Deallocate(src_iter);
      return -1;
  }

  needs_api = NpyIter_IterationNeedsAPI(dst_iter) ||
              NpyIter_IterationNeedsAPI(src_iter);

  /*
   * Because buffering is disabled in the iterator, the inner loop
   * strides will be the same throughout the iteration loop.  Thus,
   * we can pass them to this function to take advantage of
   * contiguous strides, etc.
   */
  NPY_cast_info cast_info;
  if (PyArray_GetDTypeTransferFunction(
                  IsUintAligned(src) && IsAligned(src) &&
                  IsUintAligned(dst) && IsAligned(dst),
                  src_stride, dst_stride,
                  PyArray_DESCR(src), PyArray_DESCR(dst),
                  0,
                  &cast_info, &needs_api) != NPY_SUCCEED1) {
      NpyIter_Deallocate(dst_iter);
      NpyIter_Deallocate(src_iter);
      return -1;
  }

  if (!needs_api) {
      NPY_BEGIN_THREADSdo {_save = PyEval_SaveThread();} while (0);;
  }

  dst_count = *dst_countptr;
  src_count = *src_countptr;
  char *args[2] = {src_dataptr[0], dst_dataptr[0]};
  npy_intp strides[2] = {src_stride, dst_stride};

  int res = 0;
  for(;;) {
      /* Transfer the biggest amount that fits both */
      count = (src_count < dst_count) ? src_count : dst_count;
      if (cast_info.func(&cast_info.context,
              args, &count, strides, cast_info.auxdata) < 0) {
          res = -1;
          break;
      }

      /* If we exhausted the dst block, refresh it */
      if (dst_count == count) {
          res = dst_iternext(dst_iter);
          if (!res) {
              break;
          }
          dst_count = *dst_countptr;
          args[1] = dst_dataptr[0];
      }
      else {
          dst_count -= count;
          args[1] += count*dst_stride;
      }

      /* If we exhausted the src block, refresh it */
      if (src_count == count) {
          res = src_iternext(src_iter);
          if (!res) {
              break;
          }
          src_count = *src_countptr;
          args[0] = src_dataptr[0];
      }
      else {
          src_count -= count;
          args[0] += count*src_stride;
      }
  }

  NPY_END_THREADSdo { if (_save) { PyEval_RestoreThread(_save); _save = ((void
*)0);} } while (0);;

  NPY_cast_info_xfree(&cast_info);
  NpyIter_Deallocate(dst_iter);
  NpyIter_Deallocate(src_iter);
  if (res > 0) {
      /* The iteration stopped successfully, do not report an error */
      return 0;
  }
  return res;
2744}

2746/*NUMPY_API
* Copy an Array into another array -- memory must not overlap
* Does not require src and dest to have "broadcastable" shapes
* (only the same number of elements).
*
* TODO: For NumPy 2.0, this could accept an order parameter which
*       only allows NPY_CORDER and NPY_FORDER.  Could also rename
*       this to CopyAsFlat to make the name more intuitive.
*
* Returns 0 on success, -1 on error.
*/
2757NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
2758PyArray_CopyAnyInto(PyArrayObject *dst, PyArrayObject *src)
2759{
  return PyArray_CopyAsFlat(dst, src, NPY_CORDER);
2761}

2763/*NUMPY_API
* Copy an Array into another array.
* Broadcast to the destination shape if necessary.
*
* Returns 0 on success, -1 on failure.
*/
2769NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
2770PyArray_CopyInto(PyArrayObject *dst, PyArrayObject *src)
2771{
  return PyArray_AssignArray(dst, src, NULL((void*)0), NPY_UNSAFE_CASTING);
2773}

2775/*NUMPY_API
* Move the memory of one array into another, allowing for overlapping data.
*
* Returns 0 on success, negative on failure.
*/
2780NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
2781PyArray_MoveInto(PyArrayObject *dst, PyArrayObject *src)
2782{
  return PyArray_AssignArray(dst, src, NULL((void*)0), NPY_UNSAFE_CASTING);
2784}

2786/*NUMPY_API
* PyArray_CheckAxis
*
* check that axis is valid
* convert 0-d arrays to 1-d arrays
*/
2792NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2793PyArray_CheckAxis(PyArrayObject *arr, int *axis, int flags)
2794{
  PyObject *temp1, *temp2;
  int n = PyArray_NDIM(arr);

  if (*axis == NPY_MAXDIMS32 || n == 0) {
      if (n != 1) {
          temp1 = PyArray_Ravel(arr,0);
          if (temp1 == NULL((void*)0)) {
              *axis = 0;
              return NULL((void*)0);
          }
          if (*axis == NPY_MAXDIMS32) {
              *axis = PyArray_NDIM((PyArrayObject *)temp1)-1;
          }
      }
      else {
          temp1 = (PyObject *)arr;
          Py_INCREF(temp1)_Py_INCREF(((PyObject*)(temp1)));
          *axis = 0;
      }
      if (!flags && *axis == 0) {
          return temp1;
      }
  }
  else {
      temp1 = (PyObject *)arr;
      Py_INCREF(temp1)_Py_INCREF(((PyObject*)(temp1)));
  }
  if (flags) {
      temp2 = PyArray_CheckFromAny((PyObject *)temp1, NULL((void*)0),
                                   0, 0, flags, NULL((void*)0));
      Py_DECREF(temp1)_Py_DECREF(((PyObject*)(temp1)));
      if (temp2 == NULL((void*)0)) {
          return NULL((void*)0);
      }
  }
  else {
      temp2 = (PyObject *)temp1;
  }
  n = PyArray_NDIM((PyArrayObject *)temp2);
  if (check_and_adjust_axis(axis, n) < 0) {
      Py_DECREF(temp2)_Py_DECREF(((PyObject*)(temp2)));
      return NULL((void*)0);
  }
  return temp2;
2839}

2841/*NUMPY_API
* Zeros
*
* steals a reference to type. On failure or when dtype->subarray is
* true, dtype will be decrefed.
* accepts NULL type
*/
2848NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2849PyArray_Zeros(int nd, npy_intp const *dims, PyArray_Descr *type, int is_f_order)
2850{
  PyArrayObject *ret;

  if (!type) {
      type = PyArray_DescrFromType(NPY_DEFAULT_TYPENPY_DOUBLE);
  }

  ret = (PyArrayObject *)PyArray_NewFromDescr_int(
          &PyArray_Type, type,
          nd, dims, NULL((void*)0), NULL((void*)0),
          is_f_order, NULL((void*)0), NULL((void*)0),
          1, 0);

  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* handle objects */
  if (PyDataType_REFCHK(PyArray_DESCR(ret))(((PyArray_DESCR(ret))->flags & (0x01)) == (0x01))) {
      if (_zerofill(ret) < 0) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return NULL((void*)0);
      }
  }


  return (PyObject *)ret;

2878}

2880/*NUMPY_API
* Empty
*
* accepts NULL type
* steals a reference to type
*/
2886NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2887PyArray_Empty(int nd, npy_intp const *dims, PyArray_Descr *type, int is_f_order)
2888{
  PyArrayObject *ret;

  if (!type) type = PyArray_DescrFromType(NPY_DEFAULT_TYPENPY_DOUBLE);

  /*
   * PyArray_NewFromDescr steals a ref,
   * but we need to look at type later.
   * */
  Py_INCREF(type)_Py_INCREF(((PyObject*)(type)));

  ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type,
                                              type, nd, dims,
                                              NULL((void*)0), NULL((void*)0),
                                              is_f_order, NULL((void*)0));
  if (ret != NULL((void*)0) && PyDataType_REFCHK(type)(((type)->flags & (0x01)) == (0x01))) {
      PyArray_FillObjectArray(ret, Py_None(&_Py_NoneStruct));
      if (PyErr_Occurred()) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
          return NULL((void*)0);
      }
  }

  Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
  return (PyObject *)ret;
2914}

2916/*
* Like ceil(value), but check for overflow.
*
* Return 0 on success, -1 on failure. In case of failure, set a PyExc_Overflow
* exception
*/
2922static npy_intp
2923_arange_safe_ceil_to_intp(double value)
2924{
  double ivalue;

  ivalue = npy_ceil(value);
  /* condition inverted to handle NaN */
  if (npy_isnan(ivalue)) {
      PyErr_SetString(PyExc_ValueError,
          "arange: cannot compute length");
      return -1;
  }
  if (!((double)NPY_MIN_INTP(-9223372036854775807L -1L) <= ivalue && ivalue <= (double)NPY_MAX_INTP9223372036854775807L)) {
      PyErr_SetString(PyExc_OverflowError,
              "arange: overflow while computing length");
      return -1;
  }

  return (npy_intp)ivalue;
2941}


2944/*NUMPY_API
Arange,
2946*/
2947NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
2948PyArray_Arange(double start, double stop, double step, int type_num)
2949{
  npy_intp length;
  PyArrayObject *range;
  PyArray_ArrFuncs *funcs;
  PyObject *obj;
  int ret;
  double delta, tmp_len;
  NPY_BEGIN_THREADS_DEFPyThreadState *_save=((void*)0);;

  delta = stop - start;
  tmp_len = delta/step;

  /* Underflow and divide-by-inf check */
  if (tmp_len == 0.0 && delta != 0.0) {
      if (npy_signbit(tmp_len)) {
          length = 0;
      }
      else {
          length = 1;
      }
  }
  else {
      length = _arange_safe_ceil_to_intp(tmp_len);
      if (error_converting(length)(((length) == -1) && PyErr_Occurred())) {
          return NULL((void*)0);
      }
  }

  if (length <= 0) {
      length = 0;
      return PyArray_New(&PyArray_Type, 1, &length, type_num,
                         NULL((void*)0), NULL((void*)0), 0, 0, NULL((void*)0));
  }
  range = (PyArrayObject *)PyArray_New(&PyArray_Type, 1, &length, type_num,
                      NULL((void*)0), NULL((void*)0), 0, 0, NULL((void*)0));
  if (range == NULL((void*)0)) {
      return NULL((void*)0);
  }
  funcs = PyArray_DESCR(range)->f;

  /*
   * place start in the buffer and the next value in the second position
   * if length > 2, then call the inner loop, otherwise stop
   */
  obj = PyFloat_FromDouble(start);
  ret = funcs->setitem(obj, PyArray_DATA(range), range);
  Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
  if (ret < 0) {
      goto fail;
  }
  if (length == 1) {
      return (PyObject *)range;
  }
  obj = PyFloat_FromDouble(start + step);
  ret = funcs->setitem(obj, PyArray_BYTES(range)+PyArray_ITEMSIZE(range),
                       range);
  Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
  if (ret < 0) {
      goto fail;
  }
  if (length == 2) {
      return (PyObject *)range;
  }
  if (!funcs->fill) {
      PyErr_SetString(PyExc_ValueError,
              "no fill-function for data-type.");
      Py_DECREF(range)_Py_DECREF(((PyObject*)(range)));
      return NULL((void*)0);
  }
  NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(range))do {if (!(((((PyArray_DESCR(range)))->flags & (0x10)) ==
 (0x10)))) do {_save = PyEval_SaveThread();} while (0);;} while
 (0);;
  funcs->fill(PyArray_DATA(range), length, range);
  NPY_END_THREADSdo { if (_save) { PyEval_RestoreThread(_save); _save = ((void
*)0);} } while (0);;
  if (PyErr_Occurred()) {
      goto fail;
  }
  return (PyObject *)range;

fail:
  Py_DECREF(range)_Py_DECREF(((PyObject*)(range)));
  return NULL((void*)0);
3029}

3031/*
* the formula is len = (intp) ceil((stop - start) / step);
*/
3034static npy_intp
3035_calc_length(PyObject *start, PyObject *stop, PyObject *step, PyObject **next, int cmplx)
3036{
  npy_intp len, tmp;
  PyObject *zero, *val;
  int next_is_nonzero, val_is_zero;
  double value;

  *next = PyNumber_Subtract(stop, start);
  if (!(*next)) {
      if (PyTuple_Check(stop)((((((PyObject*)(stop))->ob_type))->tp_flags & ((1UL
 << 26))) != 0)) {
          PyErr_Clear();
          PyErr_SetString(PyExc_TypeError,
                          "arange: scalar arguments expected "\
                          "instead of a tuple.");
      }
      return -1;
  }

  zero = PyLong_FromLong(0);
  if (!zero) {
      Py_DECREF(*next)_Py_DECREF(((PyObject*)(*next)));
      *next = NULL((void*)0);
      return -1;
  }

  next_is_nonzero = PyObject_RichCompareBool(*next, zero, Py_NE3);
  if (next_is_nonzero == -1) {
      Py_DECREF(zero)_Py_DECREF(((PyObject*)(zero)));
      Py_DECREF(*next)_Py_DECREF(((PyObject*)(*next)));
      *next = NULL((void*)0);
      return -1;
  }
  val = PyNumber_TrueDivide(*next, step);
  Py_DECREF(*next)_Py_DECREF(((PyObject*)(*next)));
  *next = NULL((void*)0);

  if (!val) {
      Py_DECREF(zero)_Py_DECREF(((PyObject*)(zero)));
      return -1;
  }

  val_is_zero = PyObject_RichCompareBool(val, zero, Py_EQ2);
  Py_DECREF(zero)_Py_DECREF(((PyObject*)(zero)));
  if (val_is_zero == -1) {
      Py_DECREF(val)_Py_DECREF(((PyObject*)(val)));
      return -1;
  }

  if (cmplx && PyComplex_Check(val)((((PyObject*)(val))->ob_type) == (&PyComplex_Type) ||
 PyType_IsSubtype((((PyObject*)(val))->ob_type), (&PyComplex_Type
)))) {
      value = PyComplex_RealAsDouble(val);
      if (error_converting(value)(((value) == -1) && PyErr_Occurred())) {
          Py_DECREF(val)_Py_DECREF(((PyObject*)(val)));
          return -1;
      }
      len = _arange_safe_ceil_to_intp(value);
      if (error_converting(len)(((len) == -1) && PyErr_Occurred())) {
          Py_DECREF(val)_Py_DECREF(((PyObject*)(val)));
          return -1;
      }
      value = PyComplex_ImagAsDouble(val);
      Py_DECREF(val)_Py_DECREF(((PyObject*)(val)));
      if (error_converting(value)(((value) == -1) && PyErr_Occurred())) {
          return -1;
      }
      tmp = _arange_safe_ceil_to_intp(value);
      if (error_converting(tmp)(((tmp) == -1) && PyErr_Occurred())) {
          return -1;
      }
      len = PyArray_MIN(len, tmp)(((len)<(tmp))?(len):(tmp));
  }
  else {
      value = PyFloat_AsDouble(val);
      Py_DECREF(val)_Py_DECREF(((PyObject*)(val)));
      if (error_converting(value)(((value) == -1) && PyErr_Occurred())) {
          return -1;
      }

      /* Underflow and divide-by-inf check */
      if (val_is_zero && next_is_nonzero) {
          if (npy_signbit(value)) {
              len = 0;
          }
          else {
              len = 1;
          }
      }
      else {
          len = _arange_safe_ceil_to_intp(value);
          if (error_converting(len)(((len) == -1) && PyErr_Occurred())) {
              return -1;
          }
      }
  }

  if (len > 0) {
      *next = PyNumber_Add(start, step);
      if (!*next) {
          return -1;
      }
  }
  return len;
3136}

3138/*NUMPY_API
*
* ArangeObj,
*
* this doesn't change the references
*/
3144NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
3145PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr *dtype)
3146{
  PyArrayObject *range;
  PyArray_ArrFuncs *funcs;
  PyObject *next, *err;
  npy_intp length;
  PyArray_Descr *native = NULL((void*)0);
  int swap;
  NPY_BEGIN_THREADS_DEFPyThreadState *_save=((void*)0);;

  /* Datetime arange is handled specially */
  if ((dtype != NULL((void*)0) && (dtype->type_num == NPY_DATETIME ||
                         dtype->type_num == NPY_TIMEDELTA)) ||
          (dtype == NULL((void*)0) && (is_any_numpy_datetime_or_timedelta(start) ||
                            is_any_numpy_datetime_or_timedelta(stop) ||
                            is_any_numpy_datetime_or_timedelta(step)))) {
      return (PyObject *)datetime_arange(start, stop, step, dtype);
  }

  if (!dtype) {
      PyArray_Descr *deftype;
      PyArray_Descr *newtype;

      /* intentionally made to be at least NPY_LONG */
      deftype = PyArray_DescrFromType(NPY_LONG);
      newtype = PyArray_DescrFromObject(start, deftype);
      Py_DECREF(deftype)_Py_DECREF(((PyObject*)(deftype)));
      if (newtype == NULL((void*)0)) {
          return NULL((void*)0);
      }
      deftype = newtype;
      if (stop && stop != Py_None(&_Py_NoneStruct)) {
          newtype = PyArray_DescrFromObject(stop, deftype);
          Py_DECREF(deftype)_Py_DECREF(((PyObject*)(deftype)));
          if (newtype == NULL((void*)0)) {
              return NULL((void*)0);
          }
          deftype = newtype;
      }
      if (step && step != Py_None(&_Py_NoneStruct)) {
          newtype = PyArray_DescrFromObject(step, deftype);
          Py_DECREF(deftype)_Py_DECREF(((PyObject*)(deftype)));
          if (newtype == NULL((void*)0)) {
              return NULL((void*)0);
          }
          deftype = newtype;
      }
      dtype = deftype;
  }
  else {
      Py_INCREF(dtype)_Py_INCREF(((PyObject*)(dtype)));
  }
  if (!step || step == Py_None(&_Py_NoneStruct)) {
      step = PyLong_FromLong(1);
  }
  else {
      Py_XINCREF(step)_Py_XINCREF(((PyObject*)(step)));
  }
  if (!stop || stop == Py_None(&_Py_NoneStruct)) {
      stop = start;
      start = PyLong_FromLong(0);
  }
  else {
      Py_INCREF(start)_Py_INCREF(((PyObject*)(start)));
  }
  /* calculate the length and next = start + step*/
  length = _calc_length(start, stop, step, &next,
                        PyTypeNum_ISCOMPLEX(dtype->type_num)(((dtype->type_num) >= NPY_CFLOAT) && ((dtype->
type_num) <= NPY_CLONGDOUBLE)));
  err = PyErr_Occurred();
  if (err) {
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
      if (err && PyErr_GivenExceptionMatches(err, PyExc_OverflowError)) {
          PyErr_SetString(PyExc_ValueError, "Maximum allowed size exceeded");
      }
      goto fail;
  }
  if (length <= 0) {
      length = 0;
      range = (PyArrayObject *)PyArray_SimpleNewFromDescr(1, &length, dtype)PyArray_NewFromDescr(&PyArray_Type, dtype, 1, &length
, ((void*)0), ((void*)0), 0, ((void*)0));
      Py_DECREF(step)_Py_DECREF(((PyObject*)(step)));
      Py_DECREF(start)_Py_DECREF(((PyObject*)(start)));
      return (PyObject *)range;
  }

  /*
   * If dtype is not in native byte-order then get native-byte
   * order version.  And then swap on the way out.
   */
  if (!PyArray_ISNBO(dtype->byteorder)((dtype->byteorder) != '>')) {
      native = PyArray_DescrNewByteorder(dtype, NPY_NATBYTE'<');
      swap = 1;
  }
  else {
      native = dtype;
      swap = 0;
  }

  range = (PyArrayObject *)PyArray_SimpleNewFromDescr(1, &length, native)PyArray_NewFromDescr(&PyArray_Type, native, 1, &length
, ((void*)0), ((void*)0), 0, ((void*)0));
  if (range == NULL((void*)0)) {
      goto fail;
  }

  /*
   * place start in the buffer and the next value in the second position
   * if length > 2, then call the inner loop, otherwise stop
   */
  funcs = PyArray_DESCR(range)->f;
  if (funcs->setitem(start, PyArray_DATA(range), range) < 0) {
      goto fail;
  }
  if (length == 1) {
      goto finish;
  }
  if (funcs->setitem(next, PyArray_BYTES(range)+PyArray_ITEMSIZE(range),
                     range) < 0) {
      goto fail;
  }
  if (length == 2) {
      goto finish;
  }
  if (!funcs->fill) {
      PyErr_SetString(PyExc_ValueError, "no fill-function for data-type.");
      Py_DECREF(range)_Py_DECREF(((PyObject*)(range)));
      goto fail;
  }
  NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(range))do {if (!(((((PyArray_DESCR(range)))->flags & (0x10)) ==
 (0x10)))) do {_save = PyEval_SaveThread();} while (0);;} while
 (0);;
  funcs->fill(PyArray_DATA(range), length, range);
  NPY_END_THREADSdo { if (_save) { PyEval_RestoreThread(_save); _save = ((void
*)0);} } while (0);;
  if (PyErr_Occurred()) {
      goto fail;
  }
finish:
  /* TODO: This swapping could be handled on the fly by the nditer */
  if (swap) {
      PyObject *new;
      new = PyArray_Byteswap(range, 1);
      Py_DECREF(new)_Py_DECREF(((PyObject*)(new)));
      Py_DECREF(PyArray_DESCR(range))_Py_DECREF(((PyObject*)(PyArray_DESCR(range))));
      /* steals the reference */
      ((PyArrayObject_fields *)range)->descr = dtype;
  }
  Py_DECREF(start)_Py_DECREF(((PyObject*)(start)));
  Py_DECREF(step)_Py_DECREF(((PyObject*)(step)));
  Py_DECREF(next)_Py_DECREF(((PyObject*)(next)));
  return (PyObject *)range;

fail:
  Py_DECREF(start)_Py_DECREF(((PyObject*)(start)));
  Py_DECREF(step)_Py_DECREF(((PyObject*)(step)));
  Py_XDECREF(next)_Py_XDECREF(((PyObject*)(next)));
  return NULL((void*)0);
3296}

3298/* This array creation function does not steal the reference to dtype. */
3299static PyArrayObject *
3300array_fromfile_binary(FILE *fp, PyArray_Descr *dtype, npy_intp num, size_t *nread)
3301{
  PyArrayObject *r;
  npy_off_toff_t start, numbytes;
  int elsize;

  if (num < 0) {
      int fail = 0;
      start = npy_ftellftello(fp);
      if (start < 0) {
          fail = 1;
      }
      if (npy_fseekfseeko(fp, 0, SEEK_END2) < 0) {
          fail = 1;
      }
      numbytes = npy_ftellftello(fp);
      if (numbytes < 0) {
          fail = 1;
      }
      numbytes -= start;
      if (npy_fseekfseeko(fp, start, SEEK_SET0) < 0) {
          fail = 1;
      }
      if (fail) {
          PyErr_SetString(PyExc_IOError,
                          "could not seek in file");
          return NULL((void*)0);
      }
      num = numbytes / dtype->elsize;
  }

  /*
   * Array creation may move sub-array dimensions from the dtype to array
   * dimensions, so we need to use the original element size when reading.
   */
  elsize = dtype->elsize;

  Py_INCREF(dtype)_Py_INCREF(((PyObject*)(dtype)));  /* do not steal the original dtype. */
  r = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype, 1, &num,
                                            NULL((void*)0), NULL((void*)0), 0, NULL((void*)0));
  if (r == NULL((void*)0)) {
      return NULL((void*)0);
  }

  NPY_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();;
  *nread = fread(PyArray_DATA(r), elsize, num, fp);
  NPY_END_ALLOW_THREADSPyEval_RestoreThread(_save); };
  return r;
3348}

3350/*
* Create an array by reading from the given stream, using the passed
* next_element and skip_separator functions.
* Does not steal the reference to dtype.
*/
3355#define FROM_BUFFER_SIZE 4096
3356static PyArrayObject *
3357array_from_text(PyArray_Descr *dtype, npy_intp num, char const *sep, size_t *nread,
              void *stream, next_element next, skip_separator skip_sep,
              void *stream_data)
3360{
  PyArrayObject *r;
  npy_intp i;
  char *dptr, *clean_sep, *tmp;
  int err = 0;
  int stop_reading_flag = 0;  /* -1 means end reached; -2 a parsing error */
  npy_intp thisbuf = 0;
  npy_intp size;
  npy_intp bytes, totalbytes;

  size = (num >= 0) ? num : FROM_BUFFER_SIZE;

  /*
   * Array creation may move sub-array dimensions from the dtype to array
   * dimensions, so we need to use the original dtype when reading.
   */
  Py_INCREF(dtype)_Py_INCREF(((PyObject*)(dtype)));

  r = (PyArrayObject *)
      PyArray_NewFromDescr(&PyArray_Type, dtype, 1, &size,
                           NULL((void*)0), NULL((void*)0), 0, NULL((void*)0));
  if (r == NULL((void*)0)) {
      return NULL((void*)0);
  }

  clean_sep = swab_separator(sep);
  if (clean_sep == NULL((void*)0)) {
      err = 1;
      goto fail;
  }

  NPY_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();;
  totalbytes = bytes = size * dtype->elsize;
  dptr = PyArray_DATA(r);
  for (i = 0; num < 0 || i < num; i++) {
      stop_reading_flag = next(&stream, dptr, dtype, stream_data);
      if (stop_reading_flag < 0) {
          break;
      }
      *nread += 1;
      thisbuf += 1;
      dptr += dtype->elsize;
      if (num < 0 && thisbuf == size) {
          totalbytes += bytes;
          tmp = PyDataMem_RENEW(PyArray_DATA(r), totalbytes);
          if (tmp == NULL((void*)0)) {
              err = 1;
              break;
          }
          ((PyArrayObject_fields *)r)->data = tmp;
          dptr = tmp + (totalbytes - bytes);
          thisbuf = 0;
      }
      stop_reading_flag = skip_sep(&stream, clean_sep, stream_data);
      if (stop_reading_flag < 0) {
          if (num == i + 1) {
              /* if we read as much as requested sep is optional */
              stop_reading_flag = -1;
          }
          break;
      }
  }
  if (num < 0) {
      const size_t nsize = PyArray_MAX(*nread,1)(((*nread)>(1))?(*nread):(1))*dtype->elsize;

      if (nsize != 0) {
          tmp = PyDataMem_RENEW(PyArray_DATA(r), nsize);
          if (tmp == NULL((void*)0)) {
              err = 1;
          }
          else {
              PyArray_DIMS(r)[0] = *nread;
              ((PyArrayObject_fields *)r)->data = tmp;
          }
      }
  }
  NPY_END_ALLOW_THREADSPyEval_RestoreThread(_save); };

  free(clean_sep);

  if (stop_reading_flag == -2) {
      if (PyErr_Occurred()) {
          /* If an error is already set (unlikely), do not create new one */
          Py_DECREF(r)_Py_DECREF(((PyObject*)(r)));
          return NULL((void*)0);
      }
      /* 2019-09-12, NumPy 1.18 */
      if (DEPRECATE(PyErr_WarnEx(PyExc_DeprecationWarning,"string or file could not be read to its end due to unmatched "
 "data; this will raise a ValueError in the future.",1)
              "string or file could not be read to its end due to unmatched "PyErr_WarnEx(PyExc_DeprecationWarning,"string or file could not be read to its end due to unmatched "
 "data; this will raise a ValueError in the future.",1)
              "data; this will raise a ValueError in the future.")PyErr_WarnEx(PyExc_DeprecationWarning,"string or file could not be read to its end due to unmatched "
 "data; this will raise a ValueError in the future.",1) < 0) {
          goto fail;
      }
  }

3454fail:
  if (err == 1) {
      PyErr_NoMemory();
  }
  if (PyErr_Occurred()) {
      Py_DECREF(r)_Py_DECREF(((PyObject*)(r)));
      return NULL((void*)0);
  }
  return r;
3463}
3464#undef FROM_BUFFER_SIZE

3466/*NUMPY_API
*
* Given a ``FILE *`` pointer ``fp``, and a ``PyArray_Descr``, return an
* array corresponding to the data encoded in that file.
*
* The reference to `dtype` is stolen (it is possible that the passed in
* dtype is not held on to).
*
* The number of elements to read is given as ``num``; if it is < 0, then
* then as many as possible are read.
*
* If ``sep`` is NULL or empty, then binary data is assumed, else
* text data, with ``sep`` as the separator between elements. Whitespace in
* the separator matches any length of whitespace in the text, and a match
* for whitespace around the separator is added.
*
* For memory-mapped files, use the buffer interface. No more data than
* necessary is read by this routine.
*/
3485NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
3486PyArray_FromFile(FILE *fp, PyArray_Descr *dtype, npy_intp num, char *sep)
3487{
  PyArrayObject *ret;
  size_t nread = 0;

  if (PyDataType_REFCHK(dtype)(((dtype)->flags & (0x01)) == (0x01))) {
      PyErr_SetString(PyExc_ValueError,
              "Cannot read into object array");
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
      return NULL((void*)0);
  }
  if (dtype->elsize == 0) {
      /* Nothing to read, just create an empty array of the requested type */
      return PyArray_NewFromDescr_int(
              &PyArray_Type, dtype,
              1, &num, NULL((void*)0), NULL((void*)0),
              0, NULL((void*)0), NULL((void*)0),
              0, 1);
  }
  if ((sep == NULL((void*)0)) || (strlen(sep) == 0)) {
      ret = array_fromfile_binary(fp, dtype, num, &nread);
  }
  else {
      if (dtype->f->scanfunc == NULL((void*)0)) {
          PyErr_SetString(PyExc_ValueError,
                  "Unable to read character files of that array type");
          Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
          return NULL((void*)0);
      }
      ret = array_from_text(dtype, num, sep, &nread, fp,
              (next_element) fromfile_next_element,
              (skip_separator) fromfile_skip_separator, NULL((void*)0));
  }
  if (ret == NULL((void*)0)) {
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
      return NULL((void*)0);
  }
  if (((npy_intp) nread) < num) {
      /*
       * Realloc memory for smaller number of elements, use original dtype
       * which may have include a subarray (and is used for `nread`).
       */
      const size_t nsize = PyArray_MAX(nread,1)(((nread)>(1))?(nread):(1)) * dtype->elsize;
      char *tmp;

      if ((tmp = PyDataMem_RENEW(PyArray_DATA(ret), nsize)) == NULL((void*)0)) {
          Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return PyErr_NoMemory();
      }
      ((PyArrayObject_fields *)ret)->data = tmp;
      PyArray_DIMS(ret)[0] = nread;
  }
  Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
  return (PyObject *)ret;
3541}

3543/*NUMPY_API*/
3544NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
3545PyArray_FromBuffer(PyObject *buf, PyArray_Descr *type,
                 npy_intp count, npy_intp offset)
3547{
  PyArrayObject *ret;
  char *data;
  Py_buffer view;
  Py_ssize_t ts;
  npy_intp s, n;
  int itemsize;
  int writeable = 1;


  if (PyDataType_REFCHK(type)(((type)->flags & (0x01)) == (0x01))) {
      PyErr_SetString(PyExc_ValueError,
                      "cannot create an OBJECT array from memory"\
                      " buffer");
      Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
      return NULL((void*)0);
  }
  if (PyDataType_ISUNSIZED(type)((type)->elsize == 0 && !(((PyArray_Descr *)(type)
)->names != ((void*)0)))) {
      PyErr_SetString(PyExc_ValueError,
                      "itemsize cannot be zero in type");
      Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
      return NULL((void*)0);
  }

  if (PyObject_GetBuffer(buf, &view, PyBUF_WRITABLE0x0001|PyBUF_SIMPLE0) < 0) {
      writeable = 0;
      PyErr_Clear();
      if (PyObject_GetBuffer(buf, &view, PyBUF_SIMPLE0) < 0) {
          Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
          return NULL((void*)0);
      }
  }
  data = (char *)view.buf;
  ts = view.len;
  /*
   * In Python 3 both of the deprecated functions PyObject_AsWriteBuffer and
   * PyObject_AsReadBuffer that this code replaces release the buffer. It is
   * up to the object that supplies the buffer to guarantee that the buffer
   * sticks around after the release.
   */
  PyBuffer_Release(&view);

  if ((offset < 0) || (offset > ts)) {
      PyErr_Format(PyExc_ValueError,
                   "offset must be non-negative and no greater than buffer "\
                   "length (%" NPY_INTP_FMT"ld" ")", (npy_intp)ts);
      Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
      return NULL((void*)0);
  }

  data += offset;
  s = (npy_intp)ts - offset;
  n = (npy_intp)count;
  itemsize = type->elsize;
  if (n < 0) {
      if (itemsize == 0) {
          PyErr_SetString(PyExc_ValueError,
                          "cannot determine count if itemsize is 0");
          Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
          return NULL((void*)0);
      }
      if (s % itemsize != 0) {
          PyErr_SetString(PyExc_ValueError,
                          "buffer size must be a multiple"\
                          " of element size");
          Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
          return NULL((void*)0);
      }
      n = s/itemsize;
  }
  else {
      if (s < n*itemsize) {
          PyErr_SetString(PyExc_ValueError,
                          "buffer is smaller than requested"\
                          " size");
          Py_DECREF(type)_Py_DECREF(((PyObject*)(type)));
          return NULL((void*)0);
      }
  }

  ret = (PyArrayObject *)PyArray_NewFromDescrAndBase(
          &PyArray_Type, type,
          1, &n, NULL((void*)0), data,
          NPY_ARRAY_DEFAULT((0x0001 | (0x0100 | 0x0400))), NULL((void*)0), buf);
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }

  if (!writeable) {
      PyArray_CLEARFLAGS(ret, NPY_ARRAY_WRITEABLE0x0400);
  }
  return (PyObject *)ret;
3639}

3641/*NUMPY_API
*
* Given a pointer to a string ``data``, a string length ``slen``, and
* a ``PyArray_Descr``, return an array corresponding to the data
* encoded in that string.
*
* If the dtype is NULL, the default array type is used (double).
* If non-null, the reference is stolen.
*
* If ``slen`` is < 0, then the end of string is used for text data.
* It is an error for ``slen`` to be < 0 for binary data (since embedded NULLs
* would be the norm).
*
* The number of elements to read is given as ``num``; if it is < 0, then
* then as many as possible are read.
*
* If ``sep`` is NULL or empty, then binary data is assumed, else
* text data, with ``sep`` as the separator between elements. Whitespace in
* the separator matches any length of whitespace in the text, and a match
* for whitespace around the separator is added.
*/
3662NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
3663PyArray_FromString(char *data, npy_intp slen, PyArray_Descr *dtype,
                 npy_intp num, char *sep)
3665{
  int itemsize;
  PyArrayObject *ret;
  npy_bool binary;

  if (dtype == NULL((void*)0)) {
      dtype=PyArray_DescrFromType(NPY_DEFAULT_TYPENPY_DOUBLE);
      if (dtype == NULL((void*)0)) {
          return NULL((void*)0);
      }
  }
  if (PyDataType_FLAGCHK(dtype, NPY_ITEM_IS_POINTER)(((dtype)->flags & (0x04)) == (0x04)) ||
                  PyDataType_REFCHK(dtype)(((dtype)->flags & (0x01)) == (0x01))) {
      PyErr_SetString(PyExc_ValueError,
                      "Cannot create an object array from"    \
                      " a string");
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
      return NULL((void*)0);
  }
  itemsize = dtype->elsize;
  if (itemsize == 0) {
      PyErr_SetString(PyExc_ValueError, "zero-valued itemsize");
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
      return NULL((void*)0);
  }

  binary = ((sep == NULL((void*)0)) || (strlen(sep) == 0));
  if (binary) {
      if (num < 0 ) {
          if (slen % itemsize != 0) {
              PyErr_SetString(PyExc_ValueError,
                              "string size must be a "\
                              "multiple of element size");
              Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
              return NULL((void*)0);
          }
          num = slen/itemsize;
      }
      else {
          if (slen < num*itemsize) {
              PyErr_SetString(PyExc_ValueError,
                              "string is smaller than " \
                              "requested size");
              Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
              return NULL((void*)0);
          }
      }
      /*
       * NewFromDescr may replace dtype to absorb subarray shape
       * into the array, so get size beforehand.
       */
      npy_intp size_to_copy = num*dtype->elsize;
      ret = (PyArrayObject *)
          PyArray_NewFromDescr(&PyArray_Type, dtype,
                               1, &num, NULL((void*)0), NULL((void*)0),
                               0, NULL((void*)0));
      if (ret == NULL((void*)0)) {
          return NULL((void*)0);
      }
      memcpy(PyArray_DATA(ret), data, size_to_copy);
  }
  else {
      /* read from character-based string */
      size_t nread = 0;
      char *end;

      if (dtype->f->fromstr == NULL((void*)0)) {
          PyErr_SetString(PyExc_ValueError,
                          "don't know how to read "       \
                          "character strings with that "  \
                          "array type");
          Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
          return NULL((void*)0);
      }
      if (slen < 0) {
          end = NULL((void*)0);
      }
      else {
          end = data + slen;
      }
      ret = array_from_text(dtype, num, sep, &nread,
                            data,
                            (next_element) fromstr_next_element,
                            (skip_separator) fromstr_skip_separator,
                            end);
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
  }
  return (PyObject *)ret;
3753}

3755/*NUMPY_API
*
* steals a reference to dtype (which cannot be NULL)
*/
3759NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
3760PyArray_FromIter(PyObject *obj, PyArray_Descr *dtype, npy_intp count)
3761{
  PyObject *value;
  PyObject *iter = PyObject_GetIter(obj);
  PyArrayObject *ret = NULL((void*)0);
  npy_intp i, elsize, elcount;
  char *item, *new_data;

  if (iter == NULL((void*)0)) {
      goto done;
  }
  if (PyDataType_ISUNSIZED(dtype)((dtype)->elsize == 0 && !(((PyArray_Descr *)(dtype
))->names != ((void*)0)))) {
      PyErr_SetString(PyExc_ValueError,
              "Must specify length when using variable-size data-type.");
      goto done;
  }
  if (count < 0) {
      elcount = PyObject_LengthHint(obj, 0);
      if (elcount < 0) {
          goto done;
      }
  }
  else {
      elcount = count;
  }

  elsize = dtype->elsize;

  /*
   * We would need to alter the memory RENEW code to decrement any
   * reference counts before throwing away any memory.
   */
  if (PyDataType_REFCHK(dtype)(((dtype)->flags & (0x01)) == (0x01))) {
      PyErr_SetString(PyExc_ValueError,
              "cannot create object arrays from iterator");
      goto done;
  }

  ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype, 1,
                                              &elcount, NULL((void*)0),NULL((void*)0), 0, NULL((void*)0));
  dtype = NULL((void*)0);
  if (ret == NULL((void*)0)) {
      goto done;
  }
  for (i = 0; (i < count || count == -1) &&
           (value = PyIter_Next(iter)); i++) {
      if (i >= elcount && elsize != 0) {
          npy_intp nbytes;
          /*
            Grow PyArray_DATA(ret):
            this is similar for the strategy for PyListObject, but we use
            50% overallocation => 0, 4, 8, 14, 23, 36, 56, 86 ...
          */
          elcount = (i >> 1) + (i < 4 ? 4 : 2) + i;
          if (!npy_mul_with_overflow_intp(&nbytes, elcount, elsize)) {
              new_data = PyDataMem_RENEW(PyArray_DATA(ret), nbytes);
          }
          else {
              new_data = NULL((void*)0);
          }
          if (new_data == NULL((void*)0)) {
              PyErr_SetString(PyExc_MemoryError,
                      "cannot allocate array memory");
              Py_DECREF(value)_Py_DECREF(((PyObject*)(value)));
              goto done;
          }
          ((PyArrayObject_fields *)ret)->data = new_data;
      }
      PyArray_DIMS(ret)[0] = i + 1;

      if (((item = index2ptr(ret, i)) == NULL((void*)0)) ||
              PyArray_SETITEM(ret, item, value) == -1) {
          Py_DECREF(value)_Py_DECREF(((PyObject*)(value)));
          goto done;
      }
      Py_DECREF(value)_Py_DECREF(((PyObject*)(value)));
  }


  if (PyErr_Occurred()) {
      goto done;
  }
  if (i < count) {
      PyErr_SetString(PyExc_ValueError,
              "iterator too short");
      goto done;
  }

  /*
   * Realloc the data so that don't keep extra memory tied up
   * (assuming realloc is reasonably good about reusing space...)
   */
  if (i == 0 || elsize == 0) {
      /* The size cannot be zero for PyDataMem_RENEW. */
      goto done;
  }
  new_data = PyDataMem_RENEW(PyArray_DATA(ret), i * elsize);
  if (new_data == NULL((void*)0)) {
      PyErr_SetString(PyExc_MemoryError,
              "cannot allocate array memory");
      goto done;
  }
  ((PyArrayObject_fields *)ret)->data = new_data;

done:
  Py_XDECREF(iter)_Py_XDECREF(((PyObject*)(iter)));
  Py_XDECREF(dtype)_Py_XDECREF(((PyObject*)(dtype)));
  if (PyErr_Occurred()) {
      Py_XDECREF(ret)_Py_XDECREF(((PyObject*)(ret)));
      return NULL((void*)0);
  }
  return (PyObject *)ret;
3872}

3874/*
* This is the main array creation routine.
*
* Flags argument has multiple related meanings
* depending on data and strides:
*
* If data is given, then flags is flags associated with data.
* If strides is not given, then a contiguous strides array will be created
* and the NPY_ARRAY_C_CONTIGUOUS bit will be set.  If the flags argument
* has the NPY_ARRAY_F_CONTIGUOUS bit set, then a FORTRAN-style strides array will be
* created (and of course the NPY_ARRAY_F_CONTIGUOUS flag bit will be set).
*
* If data is not given but created here, then flags will be NPY_ARRAY_DEFAULT
* and a non-zero flags argument can be used to indicate a FORTRAN style
* array is desired.
*
* Dimensions and itemsize must have been checked for validity.
*/

3893NPY_NO_EXPORT__attribute__((visibility("hidden"))) void
3894_array_fill_strides(npy_intp *strides, npy_intp const *dims, int nd, size_t itemsize,
                  int inflag, int *objflags)
3896{
  int i;
3898#if NPY_RELAXED_STRIDES_CHECKING1
  npy_bool not_cf_contig = 0;
  npy_bool nod = 0; /* A dim != 1 was found */

  /* Check if new array is both F- and C-contiguous */
  for (i = 0; i < nd; i++) {
      if (dims[i] != 1) {
          if (nod) {
              not_cf_contig = 1;
              break;
          }
          nod = 1;
      }
  }
3912#endif /* NPY_RELAXED_STRIDES_CHECKING */

  /* Only make Fortran strides if not contiguous as well */
  if ((inflag & (NPY_ARRAY_F_CONTIGUOUS0x0002|NPY_ARRAY_C_CONTIGUOUS0x0001)) ==
                                          NPY_ARRAY_F_CONTIGUOUS0x0002) {
      for (i = 0; i < nd; i++) {
          strides[i] = itemsize;
          if (dims[i]) {
              itemsize *= dims[i];
          }
3922#if NPY_RELAXED_STRIDES_CHECKING1
          else {
              not_cf_contig = 0;
          }
3926#if NPY_RELAXED_STRIDES_DEBUG0
          /* For testing purpose only */
          if (dims[i] == 1) {
              strides[i] = NPY_MAX_INTP9223372036854775807L;
          }
3931#endif /* NPY_RELAXED_STRIDES_DEBUG */
3932#endif /* NPY_RELAXED_STRIDES_CHECKING */
      }
3934#if NPY_RELAXED_STRIDES_CHECKING1
      if (not_cf_contig) {
3936#else /* not NPY_RELAXED_STRIDES_CHECKING */
      if ((nd > 1) && ((strides[0] != strides[nd-1]) || (dims[nd-1] > 1))) {
3938#endif /* not NPY_RELAXED_STRIDES_CHECKING */
          *objflags = ((*objflags)|NPY_ARRAY_F_CONTIGUOUS0x0002) &
                                          ~NPY_ARRAY_C_CONTIGUOUS0x0001;
      }
      else {
          *objflags |= (NPY_ARRAY_F_CONTIGUOUS0x0002|NPY_ARRAY_C_CONTIGUOUS0x0001);
      }
  }
  else {
      for (i = nd - 1; i >= 0; i--) {
          strides[i] = itemsize;
          if (dims[i]) {
              itemsize *= dims[i];
          }
3952#if NPY_RELAXED_STRIDES_CHECKING1
          else {
              not_cf_contig = 0;
          }
3956#if NPY_RELAXED_STRIDES_DEBUG0
          /* For testing purpose only */
          if (dims[i] == 1) {
              strides[i] = NPY_MAX_INTP9223372036854775807L;
          }
3961#endif /* NPY_RELAXED_STRIDES_DEBUG */
3962#endif /* NPY_RELAXED_STRIDES_CHECKING */
      }
3964#if NPY_RELAXED_STRIDES_CHECKING1
      if (not_cf_contig) {
3966#else /* not NPY_RELAXED_STRIDES_CHECKING */
      if ((nd > 1) && ((strides[0] != strides[nd-1]) || (dims[0] > 1))) {
3968#endif /* not NPY_RELAXED_STRIDES_CHECKING */
          *objflags = ((*objflags)|NPY_ARRAY_C_CONTIGUOUS0x0001) &
                                          ~NPY_ARRAY_F_CONTIGUOUS0x0002;
      }
      else {
          *objflags |= (NPY_ARRAY_C_CONTIGUOUS0x0001|NPY_ARRAY_F_CONTIGUOUS0x0002);
      }
  }
  return;
3977}

3979/*
* Calls arr_of_subclass.__array_wrap__(towrap), in order to make 'towrap'
* have the same ndarray subclass as 'arr_of_subclass'.
*/
3983NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArrayObject *
3984PyArray_SubclassWrap(PyArrayObject *arr_of_subclass, PyArrayObject *towrap)
3985{
  PyObject *wrapped = PyObject_CallMethod_PyObject_CallMethod_SizeT((PyObject *)arr_of_subclass,
                                      "__array_wrap__", "O", towrap);
  if (wrapped == NULL((void*)0)) {
      return NULL((void*)0);
  }
  if (!PyArray_Check(wrapped)((((PyObject*)(wrapped))->ob_type) == (&PyArray_Type) ||
 PyType_IsSubtype((((PyObject*)(wrapped))->ob_type), (&
PyArray_Type)))) {
      PyErr_SetString(PyExc_RuntimeError,
              "ndarray subclass __array_wrap__ method returned an "
              "object which was not an instance of an ndarray subclass");
      Py_DECREF(wrapped)_Py_DECREF(((PyObject*)(wrapped)));
      return NULL((void*)0);
  }

  return (PyArrayObject *)wrapped;
4000}