numpy/core/src/multiarray/ctors.c

Bug Summary

File:	numpy/core/src/multiarray/ctors.c
Warning:	line 2870, column 13 Calling function '_Py_DECREF' with a PyObject argument whose ownership has been released

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 ctors.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/ctors.c

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)))) {
      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) {
1
Assuming 'type' is non-null→
2
←
Taking false branch→
      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)) {
3
←
Assuming 'ret' is not equal to NULL→
4
←
Taking false branch→
      return NULL((void*)0);
  }

  /* handle objects */
  if (PyDataType_REFCHK(PyArray_DESCR(ret))(((PyArray_DESCR(ret))->flags & (0x01)) == (0x01))) {
5
←
Assuming the condition is true→
6
←
Taking true branch→
      if (_zerofill(ret) < 0) {
7
←
Calling '_zerofill'→
14
←
Returning from '_zerofill'→
15
←
Taking true branch→
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
16
←
Calling function '_Py_DECREF' with a PyObject argument whose ownership has been released
          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)__builtin_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)__builtin_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)__builtin_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}

←

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

→

1#define PY_SSIZE_T_CLEAN
2#include <Python.h>

4#define NPY_NO_DEPRECATED_API0x0000000E NPY_API_VERSION0x0000000E
5#define _MULTIARRAYMODULE
6#include "numpy/arrayobject.h"

8#include "npy_config.h"
9#include "npy_pycompat.h"
10#include "common.h"

12#include "abstractdtypes.h"
13#include "usertypes.h"

15#include "npy_buffer.h"

17#include "get_attr_string.h"
18#include "mem_overlap.h"
19#include "array_coercion.h"

21/*
* The casting to use for implicit assignment operations resulting from
* in-place operations (like +=) and out= arguments. (Notice that this
* variable is misnamed, but it's part of the public API so I'm not sure we
* can just change it. Maybe someone should try and see if anyone notices.
*/
27/*
* In numpy 1.6 and earlier, this was NPY_UNSAFE_CASTING. In a future
* release, it will become NPY_SAME_KIND_CASTING.  Right now, during the
* transitional period, we continue to follow the NPY_UNSAFE_CASTING rules (to
* avoid breaking people's code), but we also check for whether the cast would
* be allowed under the NPY_SAME_KIND_CASTING rules, and if not we issue a
* warning (that people's code will be broken in a future release.)
*/

36NPY_NO_EXPORT__attribute__((visibility("hidden"))) NPY_CASTING NPY_DEFAULT_ASSIGN_CASTING = NPY_SAME_KIND_CASTING;


39NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArray_Descr *
40_array_find_python_scalar_type(PyObject *op)
41{
  if (PyFloat_Check(op)((((PyObject*)(op))->ob_type) == (&PyFloat_Type) || PyType_IsSubtype
((((PyObject*)(op))->ob_type), (&PyFloat_Type)))) {
      return PyArray_DescrFromType(NPY_DOUBLE);
  }
  else if (PyComplex_Check(op)((((PyObject*)(op))->ob_type) == (&PyComplex_Type) || PyType_IsSubtype
((((PyObject*)(op))->ob_type), (&PyComplex_Type)))) {
      return PyArray_DescrFromType(NPY_CDOUBLE);
  }
  else if (PyLong_Check(op)((((((PyObject*)(op))->ob_type))->tp_flags & ((1UL <<
 24))) != 0)) {
      return PyArray_PyIntAbstractDType.discover_descr_from_pyobject(
                  &PyArray_PyIntAbstractDType, op);
  }
  return NULL((void*)0);
53}


56/*
* Get a suitable string dtype by calling `__str__`.
* For `np.bytes_`, this assumes an ASCII encoding.
*/
60NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArray_Descr *
61PyArray_DTypeFromObjectStringDiscovery(
      PyObject *obj, PyArray_Descr *last_dtype, int string_type)
63{
  int itemsize;

  if (string_type == NPY_STRING) {
      PyObject *temp = PyObject_Str(obj);
      if (temp == NULL((void*)0)) {
          return NULL((void*)0);
      }
      /* assume that when we do the encoding elsewhere we'll use ASCII */
      itemsize = PyUnicode_GetLength(temp);
      Py_DECREF(temp)_Py_DECREF(((PyObject*)(temp)));
      if (itemsize < 0) {
          return NULL((void*)0);
      }
  }
  else if (string_type == NPY_UNICODE) {
      PyObject *temp = PyObject_Str(obj);
      if (temp == NULL((void*)0)) {
          return NULL((void*)0);
      }
      itemsize = PyUnicode_GetLength(temp);
      Py_DECREF(temp)_Py_DECREF(((PyObject*)(temp)));
      if (itemsize < 0) {
          return NULL((void*)0);
      }
      itemsize *= 4;  /* convert UCS4 codepoints to bytes */
  }
  else {
      return NULL((void*)0);
  }
  if (last_dtype != NULL((void*)0) &&
      last_dtype->type_num == string_type &&
      last_dtype->elsize >= itemsize) {
      Py_INCREF(last_dtype)_Py_INCREF(((PyObject*)(last_dtype)));
      return last_dtype;
  }
  PyArray_Descr *dtype = PyArray_DescrNewFromType(string_type);
  if (dtype == NULL((void*)0)) {
      return NULL((void*)0);
  }
  dtype->elsize = itemsize;
  return dtype;
105}


108/*
* This function is now identical to the new PyArray_DiscoverDTypeAndShape
* but only returns the the dtype. It should in most cases be slowly phased
* out. (Which may need some refactoring to PyArray_FromAny to make it simpler)
*/
113NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
114PyArray_DTypeFromObject(PyObject *obj, int maxdims, PyArray_Descr **out_dtype)
115{
  coercion_cache_obj *cache = NULL((void*)0);
  npy_intp shape[NPY_MAXDIMS32];
  int ndim;

  ndim = PyArray_DiscoverDTypeAndShape(
          obj, maxdims, shape, &cache, NULL((void*)0), NULL((void*)0), out_dtype);
  if (ndim < 0) {
      return -1;
  }
  npy_free_coercion_cache(cache);
  return 0;
127}

129NPY_NO_EXPORT__attribute__((visibility("hidden"))) char *
130index2ptr(PyArrayObject *mp, npy_intp i)
131{
  npy_intp dim0;

  if (PyArray_NDIM(mp) == 0) {
      PyErr_SetString(PyExc_IndexError, "0-d arrays can't be indexed");
      return NULL((void*)0);
  }
  dim0 = PyArray_DIMS(mp)[0];
  if (check_and_adjust_index(&i, dim0, 0, NULL((void*)0)) < 0)
      return NULL((void*)0);
  if (i == 0) {
      return PyArray_DATA(mp);
  }
  return PyArray_BYTES(mp)+i*PyArray_STRIDES(mp)[0];
145}

147NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
148_zerofill(PyArrayObject *ret)
149{
  if (PyDataType_REFCHK(PyArray_DESCR(ret))(((PyArray_DESCR(ret))->flags & (0x01)) == (0x01))) {
8
←
Taking true branch→
      PyObject *zero = PyLong_FromLong(0);
      PyArray_FillObjectArray(ret, zero);
      Py_DECREF(zero)_Py_DECREF(((PyObject*)(zero)));
      if (PyErr_Occurred()) {
9
←
Assuming the condition is true→
10
←
Taking true branch→
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
11
←
Calling '_Py_DECREF'→
13
←
Returning from '_Py_DECREF'→
          return -1;
      }
  }
  else {
      npy_intp n = PyArray_NBYTES(ret)(PyArray_ITEMSIZE(ret) * PyArray_MultiplyList(PyArray_DIMS(ret
), PyArray_NDIM(ret)));
      memset(PyArray_DATA(ret), 0, n);
  }
  return 0;
164}

166NPY_NO_EXPORT__attribute__((visibility("hidden"))) npy_bool
167_IsWriteable(PyArrayObject *ap)
168{
  PyObject *base = PyArray_BASE(ap);
  Py_buffer view;

  /*
   * C-data wrapping arrays may not own their data while not having a base;
   * WRITEBACKIFCOPY arrays have a base, but do own their data.
   */
  if (base == NULL((void*)0) || PyArray_CHKFLAGS(ap, NPY_ARRAY_OWNDATA0x0004)) {
      /*
       * This is somewhat unsafe for directly wrapped non-writable C-arrays,
       * which do not know whether the memory area is writable or not and
       * do not own their data (but have no base).
       * It would be better if this returned PyArray_ISWRITEABLE(ap).
       * Since it is hard to deprecate, this is deprecated only on the Python
       * side, but not on in PyArray_UpdateFlags.
       */
      return NPY_TRUE1;
  }

  /*
   * Get to the final base object.
   * If it is a writeable array, then return True if we can
   * find an array object or a writeable buffer object as
   * the final base object.
   */
  while (PyArray_Check(base)((((PyObject*)(base))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(base))->ob_type), (&PyArray_Type)))) {
      ap = (PyArrayObject *)base;
      base = PyArray_BASE(ap);

      if (PyArray_ISWRITEABLE(ap)PyArray_CHKFLAGS((ap), 0x0400)) {
          /*
           * If any base is writeable, it must be OK to switch, note that
           * bases are typically collapsed to always point to the most
           * general one.
           */
          return NPY_TRUE1;
      }

      if (base == NULL((void*)0) || PyArray_CHKFLAGS(ap, NPY_ARRAY_OWNDATA0x0004)) {
          /* there is no further base to test the writeable flag for */
          return NPY_FALSE0;
      }
      assert(!PyArray_CHKFLAGS(ap, NPY_ARRAY_OWNDATA))((void) (0));
  }

  if (PyObject_GetBuffer(base, &view, PyBUF_WRITABLE0x0001|PyBUF_SIMPLE0) < 0) {
      PyErr_Clear();
      return NPY_FALSE0;
  }
  PyBuffer_Release(&view);
  return NPY_TRUE1;
220}


223/**
* Convert an array shape to a string such as "(1, 2)".
*
* @param Dimensionality of the shape
* @param npy_intp pointer to shape array
* @param String to append after the shape `(1, 2)%s`.
*
* @return Python unicode string
*/
232NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
233convert_shape_to_string(npy_intp n, npy_intp const *vals, char *ending)
234{
  npy_intp i;

  /*
   * Negative dimension indicates "newaxis", which can
   * be discarded for printing if it's a leading dimension.
   * Find the first non-"newaxis" dimension.
   */
  for (i = 0; i < n && vals[i] < 0; i++);

  if (i == n) {
      return PyUnicode_FromFormat("()%s", ending);
  }

  PyObject *ret = PyUnicode_FromFormat("%" NPY_INTP_FMT"ld", vals[i++]);
  if (ret == NULL((void*)0)) {
      return NULL((void*)0);
  }
  for (; i < n; ++i) {
      PyObject *tmp;

      if (vals[i] < 0) {
          tmp = PyUnicode_FromString(",newaxis");
      }
      else {
          tmp = PyUnicode_FromFormat(",%" NPY_INTP_FMT"ld", vals[i]);
      }
      if (tmp == NULL((void*)0)) {
          Py_DECREF(ret)_Py_DECREF(((PyObject*)(ret)));
          return NULL((void*)0);
      }

      Py_SETREF(ret, PyUnicode_Concat(ret, tmp))do { PyObject *_py_tmp = ((PyObject*)(ret)); (ret) = (PyUnicode_Concat
(ret, tmp)); _Py_DECREF(((PyObject*)(_py_tmp))); } while (0);
      Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));
      if (ret == NULL((void*)0)) {
          return NULL((void*)0);
      }
  }

  if (i == 1) {
      Py_SETREF(ret, PyUnicode_FromFormat("(%S,)%s", ret, ending))do { PyObject *_py_tmp = ((PyObject*)(ret)); (ret) = (PyUnicode_FromFormat
("(%S,)%s", ret, ending)); _Py_DECREF(((PyObject*)(_py_tmp)))
; } while (0);
  }
  else {
      Py_SETREF(ret, PyUnicode_FromFormat("(%S)%s", ret, ending))do { PyObject *_py_tmp = ((PyObject*)(ret)); (ret) = (PyUnicode_FromFormat
("(%S)%s", ret, ending)); _Py_DECREF(((PyObject*)(_py_tmp)));
 } while (0);
  }
  return ret;
280}


283NPY_NO_EXPORT__attribute__((visibility("hidden"))) void
284dot_alignment_error(PyArrayObject *a, int i, PyArrayObject *b, int j)
285{
  PyObject *errmsg = NULL((void*)0), *format = NULL((void*)0), *fmt_args = NULL((void*)0),
           *i_obj = NULL((void*)0), *j_obj = NULL((void*)0),
           *shape1 = NULL((void*)0), *shape2 = NULL((void*)0),
           *shape1_i = NULL((void*)0), *shape2_j = NULL((void*)0);

  format = PyUnicode_FromString("shapes %s and %s not aligned:"
                                " %d (dim %d) != %d (dim %d)");

  shape1 = convert_shape_to_string(PyArray_NDIM(a), PyArray_DIMS(a), "");
  shape2 = convert_shape_to_string(PyArray_NDIM(b), PyArray_DIMS(b), "");

  i_obj = PyLong_FromLong(i);
  j_obj = PyLong_FromLong(j);

  shape1_i = PyLong_FromSsize_t(PyArray_DIM(a, i));
  shape2_j = PyLong_FromSsize_t(PyArray_DIM(b, j));

  if (!format || !shape1 || !shape2 || !i_obj || !j_obj ||
          !shape1_i || !shape2_j) {
      goto end;
  }

  fmt_args = PyTuple_Pack(6, shape1, shape2,
                          shape1_i, i_obj, shape2_j, j_obj);
  if (fmt_args == NULL((void*)0)) {
      goto end;
  }

  errmsg = PyUnicode_Format(format, fmt_args);
  if (errmsg != NULL((void*)0)) {
      PyErr_SetObject(PyExc_ValueError, errmsg);
  }
  else {
      PyErr_SetString(PyExc_ValueError, "shapes are not aligned");
  }

322end:
  Py_XDECREF(errmsg)_Py_XDECREF(((PyObject*)(errmsg)));
  Py_XDECREF(fmt_args)_Py_XDECREF(((PyObject*)(fmt_args)));
  Py_XDECREF(format)_Py_XDECREF(((PyObject*)(format)));
  Py_XDECREF(i_obj)_Py_XDECREF(((PyObject*)(i_obj)));
  Py_XDECREF(j_obj)_Py_XDECREF(((PyObject*)(j_obj)));
  Py_XDECREF(shape1)_Py_XDECREF(((PyObject*)(shape1)));
  Py_XDECREF(shape2)_Py_XDECREF(((PyObject*)(shape2)));
  Py_XDECREF(shape1_i)_Py_XDECREF(((PyObject*)(shape1_i)));
  Py_XDECREF(shape2_j)_Py_XDECREF(((PyObject*)(shape2_j)));
332}

334/**
* unpack tuple of dtype->fields (descr, offset, title[not-needed])
*
* @param "value" should be the tuple.
*
* @return "descr" will be set to the field's dtype
* @return "offset" will be set to the field's offset
*
* returns -1 on failure, 0 on success.
*/
344NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
345_unpack_field(PyObject *value, PyArray_Descr **descr, npy_intp *offset)
346{
  PyObject * off;
  if (PyTuple_GET_SIZE(value)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(value))))->
ob_size) < 2) {
      return -1;
  }
  *descr = (PyArray_Descr *)PyTuple_GET_ITEM(value, 0)((((void) (0)), (PyTupleObject *)(value))->ob_item[0]);
  off  = PyTuple_GET_ITEM(value, 1)((((void) (0)), (PyTupleObject *)(value))->ob_item[1]);

  if (PyLong_Check(off)((((((PyObject*)(off))->ob_type))->tp_flags & ((1UL
 << 24))) != 0)) {
      *offset = PyLong_AsSsize_t(off);
  }
  else {
      PyErr_SetString(PyExc_IndexError, "can't convert offset");
      return -1;
  }

  return 0;
363}

365/*
* check whether arrays with datatype dtype might have object fields. This will
* only happen for structured dtypes (which may have hidden objects even if the
* HASOBJECT flag is false), object dtypes, or subarray dtypes whose base type
* is either of these.
*/
371NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
372_may_have_objects(PyArray_Descr *dtype)
373{
  PyArray_Descr *base = dtype;
  if (PyDataType_HASSUBARRAY(dtype)((dtype)->subarray != ((void*)0))) {
      base = dtype->subarray->base;
  }

  return (PyDataType_HASFIELDS(base)(((PyArray_Descr *)(base))->names != ((void*)0)) ||
          PyDataType_FLAGCHK(base, NPY_ITEM_HASOBJECT)(((base)->flags & (0x01)) == (0x01)) );
381}

383/*
* Make a new empty array, of the passed size, of a type that takes the
* priority of ap1 and ap2 into account.
*
* If `out` is non-NULL, memory overlap is checked with ap1 and ap2, and an
* updateifcopy temporary array may be returned. If `result` is non-NULL, the
* output array to be returned (`out` if non-NULL and the newly allocated array
* otherwise) is incref'd and put to *result.
*/
392NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyArrayObject *
393new_array_for_sum(PyArrayObject *ap1, PyArrayObject *ap2, PyArrayObject* out,
                int nd, npy_intp dimensions[], int typenum, PyArrayObject **result)
395{
  PyArrayObject *out_buf;

  if (out) {
      int d;

      /* verify that out is usable */
      if (PyArray_NDIM(out) != nd ||
          PyArray_TYPE(out) != typenum ||
          !PyArray_ISCARRAY(out)(PyArray_CHKFLAGS(out, (0x0001 | (0x0100 | 0x0400))) &&
 ((PyArray_DESCR(out)->byteorder) != '>'))) {
          PyErr_SetString(PyExc_ValueError,
              "output array is not acceptable (must have the right datatype, "
              "number of dimensions, and be a C-Array)");
          return 0;
      }
      for (d = 0; d < nd; ++d) {
          if (dimensions[d] != PyArray_DIM(out, d)) {
              PyErr_SetString(PyExc_ValueError,
                  "output array has wrong dimensions");
              return 0;
          }
      }

      /* check for memory overlap */
      if (!(solve_may_share_memory(out, ap1, 1) == 0 &&
            solve_may_share_memory(out, ap2, 1) == 0)) {
          /* allocate temporary output array */
          out_buf = (PyArrayObject *)PyArray_NewLikeArray(out, NPY_CORDER,
                                                          NULL((void*)0), 0);
          if (out_buf == NULL((void*)0)) {
              return NULL((void*)0);
          }

          /* set copy-back */
          Py_INCREF(out)_Py_INCREF(((PyObject*)(out)));
          if (PyArray_SetWritebackIfCopyBase(out_buf, out) < 0) {
              Py_DECREF(out)_Py_DECREF(((PyObject*)(out)));
              Py_DECREF(out_buf)_Py_DECREF(((PyObject*)(out_buf)));
              return NULL((void*)0);
          }
      }
      else {
          Py_INCREF(out)_Py_INCREF(((PyObject*)(out)));
          out_buf = out;
      }

      if (result) {
          Py_INCREF(out)_Py_INCREF(((PyObject*)(out)));
          *result = out;
      }

      return out_buf;
  }
  else {
      PyTypeObject *subtype;
      double prior1, prior2;
      /*
       * Need to choose an output array that can hold a sum
       * -- use priority to determine which subtype.
       */
      if (Py_TYPE(ap2)(((PyObject*)(ap2))->ob_type) != Py_TYPE(ap1)(((PyObject*)(ap1))->ob_type)) {
          prior2 = PyArray_GetPriority((PyObject *)ap2, 0.0);
          prior1 = PyArray_GetPriority((PyObject *)ap1, 0.0);
          subtype = (prior2 > prior1 ? Py_TYPE(ap2)(((PyObject*)(ap2))->ob_type) : Py_TYPE(ap1)(((PyObject*)(ap1))->ob_type));
      }
      else {
          prior1 = prior2 = 0.0;
          subtype = Py_TYPE(ap1)(((PyObject*)(ap1))->ob_type);
      }

      out_buf = (PyArrayObject *)PyArray_New(subtype, nd, dimensions,
                                             typenum, NULL((void*)0), NULL((void*)0), 0, 0,
                                             (PyObject *)
                                             (prior2 > prior1 ? ap2 : ap1));

      if (out_buf != NULL((void*)0) && result) {
          Py_INCREF(out_buf)_Py_INCREF(((PyObject*)(out_buf)));
          *result = out_buf;
      }

      return out_buf;
  }
477}


←

/opt/pyrefcon/lib/pyrefcon/models/models/_Py_DECREF.model

void _Py_DECREF(PyObject *op) { --op->ob_refcnt; }

←

Setting reference count to -1

→