numpy/core/src/umath/ufunc

Bug Summary

File:	numpy/core/src/umath/ufunc_object.c
Warning:	line 1532, column 22 PyObject ownership leak with reference count of 1
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ufunc_object.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/umath/ufunc_object.c
numpy/core/src/umath/ufunc_object.c

→
1/*
* Python Universal Functions Object -- Math for all types, plus fast
* arrays math
*
* Full description
*
* This supports mathematical (and Boolean) functions on arrays and other python
* objects.  Math on large arrays of basic C types is rather efficient.
*
* Travis E. Oliphant  2005, 2006 oliphant@ee.byu.edu (oliphant.travis@ieee.org)
* Brigham Young University
*
* based on the
*
* Original Implementation:
* Copyright (c) 1995, 1996, 1997 Jim Hugunin, hugunin@mit.edu
*
* with inspiration and code from
* Numarray
* Space Science Telescope Institute
* J. Todd Miller
* Perry Greenfield
* Rick White
*
*/
26#define _UMATHMODULE
27#define _MULTIARRAYMODULE
28#define NPY_NO_DEPRECATED_API0x0000000E NPY_API_VERSION0x0000000E

30#include "Python.h"
31#include "stddef.h"

33#include "npy_config.h"
34#include "npy_pycompat.h"
35#include "npy_argparse.h"

37#include "numpy/arrayobject.h"
38#include "numpy/ufuncobject.h"
39#include "numpy/arrayscalars.h"
40#include "lowlevel_strided_loops.h"
41#include "ufunc_type_resolution.h"
42#include "reduction.h"
43#include "mem_overlap.h"

45#include "ufunc_object.h"
46#include "override.h"
47#include "npy_import.h"
48#include "extobj.h"
49#include "common.h"
50#include "dtypemeta.h"
51#include "numpyos.h"

53/********** PRINTF DEBUG TRACING **************/
54#define NPY_UF_DBG_TRACING0 0

56#if NPY_UF_DBG_TRACING0
57#define NPY_UF_DBG_PRINT(s) {printf("%s", s)__printf_chk (2 - 1, "%s", s);fflush(stdoutstdout);}
58#define NPY_UF_DBG_PRINT1(s, p1) {printf((s), (p1))__printf_chk (2 - 1, (s), (p1));fflush(stdoutstdout);}
59#define NPY_UF_DBG_PRINT2(s, p1, p2) {printf(s, p1, p2)__printf_chk (2 - 1, s, p1, p2);fflush(stdoutstdout);}
60#define NPY_UF_DBG_PRINT3(s, p1, p2, p3) {printf(s, p1, p2, p3)__printf_chk (2 - 1, s, p1, p2, p3);fflush(stdoutstdout);}
61#else
62#define NPY_UF_DBG_PRINT(s)
63#define NPY_UF_DBG_PRINT1(s, p1)
64#define NPY_UF_DBG_PRINT2(s, p1, p2)
65#define NPY_UF_DBG_PRINT3(s, p1, p2, p3)
66#endif
67/**********************************************/

69typedef struct {
  PyObject *in;   /* The input arguments to the ufunc, a tuple */
  PyObject *out;  /* The output arguments, a tuple. If no non-None outputs are
                     provided, then this is NULL. */
73} ufunc_full_args;

75/* C representation of the context argument to __array_wrap__ */
76typedef struct {
  PyUFuncObject *ufunc;
  ufunc_full_args args;
  int out_i;
80} _ufunc_context;

82/* Get the arg tuple to pass in the context argument to __array_wrap__ and
* __array_prepare__.
*
* Output arguments are only passed if at least one is non-None.
*/
87static PyObject *
88_get_wrap_prepare_args(ufunc_full_args full_args) {
  if (full_args.out == NULL((void*)0)) {
      Py_INCREF(full_args.in)_Py_INCREF(((PyObject*)(full_args.in)));
      return full_args.in;
  }
  else {
      return PySequence_Concat(full_args.in, full_args.out);
  }
96}

98/* ---------------------------------------------------------------- */

100static PyObject *
101prepare_input_arguments_for_outer(PyObject *args, PyUFuncObject *ufunc);


104/*UFUNC_API*/
105NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
106PyUFunc_getfperr(void)
107{
  /*
   * non-clearing get was only added in 1.9 so this function always cleared
   * keep it so just in case third party code relied on the clearing
   */
  char param = 0;
  return npy_clear_floatstatus_barrier(&param);
114}

116#define HANDLEIT(NAME, str) {if (retstatus & NPY_FPE_##NAME) {          \
          handle = errmask & UFUNC_MASK_##NAME;                       \
          if (handle &&                                               \
              _error_handler(handle >> UFUNC_SHIFT_##NAME,            \
                             errobj, str, retstatus, first) < 0)      \
              return -1;                                              \
      }}

124/*UFUNC_API*/
125NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
126PyUFunc_handlefperr(int errmask, PyObject *errobj, int retstatus, int *first)
127{
  int handle;
  if (errmask && retstatus) {
      HANDLEIT(DIVIDEBYZERO, "divide by zero");
      HANDLEIT(OVERFLOW, "overflow");
      HANDLEIT(UNDERFLOW, "underflow");
      HANDLEIT(INVALID, "invalid value");
  }
  return 0;
136}

138#undef HANDLEIT


141/*UFUNC_API*/
142NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
143PyUFunc_checkfperr(int errmask, PyObject *errobj, int *first)
144{
  /* clearing is done for backward compatibility */
  int retstatus;
  retstatus = npy_clear_floatstatus_barrier((char*)&retstatus);

  return PyUFunc_handlefperr(errmask, errobj, retstatus, first);
150}


153/* Checking the status flag clears it */
154/*UFUNC_API*/
155NPY_NO_EXPORT__attribute__((visibility("hidden"))) void
156PyUFunc_clearfperr()
157{
  char param = 0;
  npy_clear_floatstatus_barrier(&param);
160}

162/*
* This function analyzes the input arguments and determines an appropriate
* method (__array_prepare__ or __array_wrap__) function to call, taking it
* from the input with the highest priority. Return NULL if no argument
* defines the method.
*/
168static PyObject*
169_find_array_method(PyObject *args, PyObject *method_name)
170{
  int i, n_methods;
  PyObject *obj;
  PyObject *with_method[NPY_MAXARGS32], *methods[NPY_MAXARGS32];
  PyObject *method = NULL((void*)0);

  n_methods = 0;
  for (i = 0; i < PyTuple_GET_SIZE(args)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(args))))->
ob_size); i++) {
      obj = PyTuple_GET_ITEM(args, i)((((void) (0)), (PyTupleObject *)(args))->ob_item[i]);
      if (PyArray_CheckExact(obj)(((PyObject*)(obj))->ob_type == &PyArray_Type) || PyArray_IsAnyScalar(obj)((((((PyObject*)(obj))->ob_type) == (&PyGenericArrType_Type
) || PyType_IsSubtype((((PyObject*)(obj))->ob_type), (&
PyGenericArrType_Type)))) || ((((((PyObject*)(obj))->ob_type
) == (&PyFloat_Type) || PyType_IsSubtype((((PyObject*)(obj
))->ob_type), (&PyFloat_Type))) || ((((PyObject*)(obj)
)->ob_type) == (&PyComplex_Type) || PyType_IsSubtype((
((PyObject*)(obj))->ob_type), (&PyComplex_Type))) || (
(((((PyObject*)(obj))->ob_type))->tp_flags & ((1UL <<
 24))) != 0) || ((((PyObject*)(obj))->ob_type) == &PyBool_Type
)) || ((((((PyObject*)(obj))->ob_type))->tp_flags &
 ((1UL << 27))) != 0) || ((((((PyObject*)(obj))->ob_type
))->tp_flags & ((1UL << 28))) != 0)))) {
          continue;
      }
      method = PyObject_GetAttr(obj, method_name);
      if (method) {
          if (PyCallable_Check(method)) {
              with_method[n_methods] = obj;
              methods[n_methods] = method;
              ++n_methods;
          }
          else {
              Py_DECREF(method)_Py_DECREF(((PyObject*)(method)));
              method = NULL((void*)0);
          }
      }
      else {
          PyErr_Clear();
      }
  }
  if (n_methods > 0) {
      /* If we have some methods defined, find the one of highest priority */
      method = methods[0];
      if (n_methods > 1) {
          double maxpriority = PyArray_GetPriority(with_method[0],
                                                   NPY_PRIORITY0.0);
          for (i = 1; i < n_methods; ++i) {
              double priority = PyArray_GetPriority(with_method[i],
                                                    NPY_PRIORITY0.0);
              if (priority > maxpriority) {
                  maxpriority = priority;
                  Py_DECREF(method)_Py_DECREF(((PyObject*)(method)));
                  method = methods[i];
              }
              else {
                  Py_DECREF(methods[i])_Py_DECREF(((PyObject*)(methods[i])));
              }
          }
      }
  }
  return method;
219}

221/*
* Returns an incref'ed pointer to the proper __array_prepare__/__array_wrap__
* method for a ufunc output argument, given the output argument `obj`, and the
* method chosen from the inputs `input_method`.
*/
226static PyObject *
227_get_output_array_method(PyObject *obj, PyObject *method,
                       PyObject *input_method) {
  if (obj != Py_None(&_Py_NoneStruct)) {
      PyObject *ometh;

      if (PyArray_CheckExact(obj)(((PyObject*)(obj))->ob_type == &PyArray_Type)) {
          /*
           * No need to wrap regular arrays - None signals to not call
           * wrap/prepare at all
           */
          Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
      }

      ometh = PyObject_GetAttr(obj, method);
      if (ometh == NULL((void*)0)) {
          PyErr_Clear();
      }
      else if (!PyCallable_Check(ometh)) {
          Py_DECREF(ometh)_Py_DECREF(((PyObject*)(ometh)));
      }
      else {
          /* Use the wrap/prepare method of the output if it's callable */
          return ometh;
      }
  }

  /* Fall back on the input's wrap/prepare */
  Py_XINCREF(input_method)_Py_XINCREF(((PyObject*)(input_method)));
  return input_method;
256}

258/*
* This function analyzes the input arguments
* and determines an appropriate __array_prepare__ function to call
* for the outputs.
*
* If an output argument is provided, then it is prepped
* with its own __array_prepare__ not with the one determined by
* the input arguments.
*
* if the provided output argument is already an ndarray,
* the prepping function is None (which means no prepping will
* be done --- not even PyArray_Return).
*
* A NULL is placed in output_prep for outputs that
* should just have PyArray_Return called.
*/
274static void
275_find_array_prepare(ufunc_full_args args,
                  PyObject **output_prep, int nout)
277{
  int i;
  PyObject *prep;

  /*
   * Determine the prepping function given by the input arrays
   * (could be NULL).
   */
  prep = _find_array_method(args.in, npy_um_str_array_prepare);
  /*
   * For all the output arrays decide what to do.
   *
   * 1) Use the prep function determined from the input arrays
   * This is the default if the output array is not
   * passed in.
   *
   * 2) Use the __array_prepare__ method of the output object.
   * This is special cased for
   * exact ndarray so that no PyArray_Return is
   * done in that case.
   */
  if (args.out == NULL((void*)0)) {
      for (i = 0; i < nout; i++) {
          Py_XINCREF(prep)_Py_XINCREF(((PyObject*)(prep)));
          output_prep[i] = prep;
      }
  }
  else {
      for (i = 0; i < nout; i++) {
          output_prep[i] = _get_output_array_method(
              PyTuple_GET_ITEM(args.out, i)((((void) (0)), (PyTupleObject *)(args.out))->ob_item[i]), npy_um_str_array_prepare, prep);
      }
  }
  Py_XDECREF(prep)_Py_XDECREF(((PyObject*)(prep)));
  return;
312}

314#define NPY_UFUNC_DEFAULT_INPUT_FLAGS0x00020000 | 0x00100000 | 0x40000000 \
  NPY_ITER_READONLY0x00020000 | \
  NPY_ITER_ALIGNED0x00100000 | \
  NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE0x40000000

319#define NPY_UFUNC_DEFAULT_OUTPUT_FLAGS0x00100000 | 0x01000000 | 0x08000000 | 0x02000000 | 0x40000000 \
  NPY_ITER_ALIGNED0x00100000 | \
  NPY_ITER_ALLOCATE0x01000000 | \
  NPY_ITER_NO_BROADCAST0x08000000 | \
  NPY_ITER_NO_SUBTYPE0x02000000 | \
  NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE0x40000000

326/* Called at module initialization to set the matmul ufunc output flags */
327NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
328set_matmul_flags(PyObject *d)
329{
  PyObject *matmul = _PyDict_GetItemStringWithError(d, "matmul");
  if (matmul == NULL((void*)0)) {
      return -1;
  }
  /*
   * The default output flag NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE allows
   * perfectly overlapping input and output (in-place operations). While
   * correct for the common mathematical operations, this assumption is
   * incorrect in the general case and specifically in the case of matmul.
   *
   * NPY_ITER_UPDATEIFCOPY is added by default in
   * PyUFunc_GeneralizedFunction, which is the variant called for gufuncs
   * with a signature
   *
   * Enabling NPY_ITER_WRITEONLY can prevent a copy in some cases.
   */
  ((PyUFuncObject *)matmul)->op_flags[2] = (NPY_ITER_WRITEONLY0x00040000 |
                                       NPY_ITER_UPDATEIFCOPY0x00800000 |
                                       NPY_UFUNC_DEFAULT_OUTPUT_FLAGS0x00100000 | 0x01000000 | 0x08000000 | 0x02000000 | 0x40000000) &
                                       ~NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE0x40000000;
  return 0;
351}


354/*
* Set per-operand flags according to desired input or output flags.
* op_flags[i] for i in input (as determined by ufunc->nin) will be
* merged with op_in_flags, perhaps overriding per-operand flags set
* in previous stages.
* op_flags[i] for i in output will be set to op_out_flags only if previously
* unset.
* The input flag behavior preserves backward compatibility, while the
* output flag behaviour is the "correct" one for maximum flexibility.
*/
364NPY_NO_EXPORT__attribute__((visibility("hidden"))) void
365_ufunc_setup_flags(PyUFuncObject *ufunc, npy_uint32 op_in_flags,
                 npy_uint32 op_out_flags, npy_uint32 *op_flags)
367{
  int nin = ufunc->nin;
  int nout = ufunc->nout;
  int nop = nin + nout, i;
  /* Set up the flags */
  for (i = 0; i < nin; ++i) {
      op_flags[i] = ufunc->op_flags[i] | op_in_flags;
      /*
       * If READWRITE flag has been set for this operand,
       * then clear default READONLY flag
       */
      if (op_flags[i] & (NPY_ITER_READWRITE0x00010000 | NPY_ITER_WRITEONLY0x00040000)) {
          op_flags[i] &= ~NPY_ITER_READONLY0x00020000;
      }
  }
  for (i = nin; i < nop; ++i) {
      op_flags[i] = ufunc->op_flags[i] ? ufunc->op_flags[i] : op_out_flags;
  }
385}

387/*
* This function analyzes the input arguments
* and determines an appropriate __array_wrap__ function to call
* for the outputs.
*
* If an output argument is provided, then it is wrapped
* with its own __array_wrap__ not with the one determined by
* the input arguments.
*
* if the provided output argument is already an array,
* the wrapping function is None (which means no wrapping will
* be done --- not even PyArray_Return).
*
* A NULL is placed in output_wrap for outputs that
* should just have PyArray_Return called.
*/
403static void
404_find_array_wrap(ufunc_full_args args, npy_bool subok,
               PyObject **output_wrap, int nin, int nout)
406{
  int i;
  PyObject *wrap = NULL((void*)0);

  /*
   * If a 'subok' parameter is passed and isn't True, don't wrap but put None
   * into slots with out arguments which means return the out argument
   */
  if (!subok) {
      goto handle_out;
  }

  /*
   * Determine the wrapping function given by the input arrays
   * (could be NULL).
   */
  wrap = _find_array_method(args.in, npy_um_str_array_wrap);

  /*
   * For all the output arrays decide what to do.
   *
   * 1) Use the wrap function determined from the input arrays
   * This is the default if the output array is not
   * passed in.
   *
   * 2) Use the __array_wrap__ method of the output object
   * passed in. -- this is special cased for
   * exact ndarray so that no PyArray_Return is
   * done in that case.
   */
436handle_out:
  if (args.out == NULL((void*)0)) {
      for (i = 0; i < nout; i++) {
          Py_XINCREF(wrap)_Py_XINCREF(((PyObject*)(wrap)));
          output_wrap[i] = wrap;
      }
  }
  else {
      for (i = 0; i < nout; i++) {
          output_wrap[i] = _get_output_array_method(
              PyTuple_GET_ITEM(args.out, i)((((void) (0)), (PyTupleObject *)(args.out))->ob_item[i]), npy_um_str_array_wrap, wrap);
      }
  }

  Py_XDECREF(wrap)_Py_XDECREF(((PyObject*)(wrap)));
451}


454/*
* Apply the __array_wrap__ function with the given array and content.
*
* Interprets wrap=None and wrap=NULL as intended by _find_array_wrap
*
* Steals a reference to obj and wrap.
* Pass context=NULL to indicate there is no context.
*/
462static PyObject *
463_apply_array_wrap(
          PyObject *wrap, PyArrayObject *obj, _ufunc_context const *context) {
  if (wrap == NULL((void*)0)) {
      /* default behavior */
      return PyArray_Return(obj);
  }
  else if (wrap == Py_None(&_Py_NoneStruct)) {
      Py_DECREF(wrap)_Py_DECREF(((PyObject*)(wrap)));
      return (PyObject *)obj;
  }
  else {
      PyObject *res;
      PyObject *py_context = NULL((void*)0);

      /* Convert the context object to a tuple, if present */
      if (context == NULL((void*)0)) {
          py_context = Py_None(&_Py_NoneStruct);
          Py_INCREF(py_context)_Py_INCREF(((PyObject*)(py_context)));
      }
      else {
          PyObject *args_tup;
          /* Call the method with appropriate context */
          args_tup = _get_wrap_prepare_args(context->args);
          if (args_tup == NULL((void*)0)) {
              goto fail;
          }
          py_context = Py_BuildValue("OOi",
              context->ufunc, args_tup, context->out_i);
          Py_DECREF(args_tup)_Py_DECREF(((PyObject*)(args_tup)));
          if (py_context == NULL((void*)0)) {
              goto fail;
          }
      }
      /* try __array_wrap__(obj, context) */
      res = PyObject_CallFunctionObjArgs(wrap, obj, py_context, NULL((void*)0));
      Py_DECREF(py_context)_Py_DECREF(((PyObject*)(py_context)));

      /* try __array_wrap__(obj) if the context argument is not accepted  */
      if (res == NULL((void*)0) && PyErr_ExceptionMatches(PyExc_TypeError)) {
          PyErr_Clear();
          res = PyObject_CallFunctionObjArgs(wrap, obj, NULL((void*)0));
      }
      Py_DECREF(wrap)_Py_DECREF(((PyObject*)(wrap)));
      Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
      return res;
  fail:
      Py_DECREF(wrap)_Py_DECREF(((PyObject*)(wrap)));
      Py_DECREF(obj)_Py_DECREF(((PyObject*)(obj)));
      return NULL((void*)0);
  }
513}


516/*UFUNC_API
*
* On return, if errobj is populated with a non-NULL value, the caller
* owns a new reference to errobj.
*/
521NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
522PyUFunc_GetPyValues(char *name, int *bufsize, int *errmask, PyObject **errobj)
523{
  PyObject *ref = get_global_ext_obj();

  return _extract_pyvals(ref, name, bufsize, errmask, errobj);
527}

529/* Return the position of next non-white-space char in the string */
530static int
531_next_non_white_space(const char* str, int offset)
532{
  int ret = offset;
  while (str[ret] == ' ' || str[ret] == '\t') {
      ret++;
  }
  return ret;
538}

540static int
541_is_alpha_underscore(char ch)
542{
  return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || ch == '_';
544}

546static int
547_is_alnum_underscore(char ch)
548{
  return _is_alpha_underscore(ch) || (ch >= '0' && ch <= '9');
550}

552/*
* Convert a string into a number
*/
555static npy_intp
556_get_size(const char* str)
557{
  char *stop;
  npy_longlong size = NumPyOS_strtoll(str, &stop, 10);

  if (stop == str || _is_alpha_underscore(*stop)) {
      /* not a well formed number */
      return -1;
  }
  if (size >= NPY_MAX_INTP9223372036854775807L || size <= NPY_MIN_INTP(-9223372036854775807L -1L)) {
      /* len(str) too long */
      return -1;
  }
  return size;
570}

572/*
* Return the ending position of a variable name including optional modifier
*/
575static int
576_get_end_of_name(const char* str, int offset)
577{
  int ret = offset;
  while (_is_alnum_underscore(str[ret])) {
      ret++;
  }
  if (str[ret] == '?') {
      ret ++;
  }
  return ret;
586}

588/*
* Returns 1 if the dimension names pointed by s1 and s2 are the same,
* otherwise returns 0.
*/
592static int
593_is_same_name(const char* s1, const char* s2)
594{
  while (_is_alnum_underscore(*s1) && _is_alnum_underscore(*s2)) {
      if (*s1 != *s2) {
          return 0;
      }
      s1++;
      s2++;
  }
  return !_is_alnum_underscore(*s1) && !_is_alnum_underscore(*s2);
603}

605/*
* Sets core_num_dim_ix, core_num_dims, core_dim_ixs, core_offsets,
* and core_signature in PyUFuncObject "ufunc".  Returns 0 unless an
* error occurred.
*/
610static int
611_parse_signature(PyUFuncObject *ufunc, const char *signature)
612{
  size_t len;
  char const **var_names;
  int nd = 0;             /* number of dimension of the current argument */
  int cur_arg = 0;        /* index into core_num_dims&core_offsets */
  int cur_core_dim = 0;   /* index into core_dim_ixs */
  int i = 0;
  char *parse_error = NULL((void*)0);

  if (signature == NULL((void*)0)) {
      PyErr_SetString(PyExc_RuntimeError,
                      "_parse_signature with NULL signature");
      return -1;
  }
  len = strlen(signature);
  ufunc->core_signature = PyArray_mallocPyMem_RawMalloc(sizeof(char) * (len+1));
  if (ufunc->core_signature) {
      strcpy(ufunc->core_signature, signature);
  }
  /* Allocate sufficient memory to store pointers to all dimension names */
  var_names = PyArray_mallocPyMem_RawMalloc(sizeof(char const*) * len);
  if (var_names == NULL((void*)0)) {
      PyErr_NoMemory();
      return -1;
  }

  ufunc->core_enabled = 1;
  ufunc->core_num_dim_ix = 0;
  ufunc->core_num_dims = PyArray_mallocPyMem_RawMalloc(sizeof(int) * ufunc->nargs);
  ufunc->core_offsets = PyArray_mallocPyMem_RawMalloc(sizeof(int) * ufunc->nargs);
  /* The next three items will be shrunk later */
  ufunc->core_dim_ixs = PyArray_mallocPyMem_RawMalloc(sizeof(int) * len);
  ufunc->core_dim_sizes = PyArray_mallocPyMem_RawMalloc(sizeof(npy_intp) * len);
  ufunc->core_dim_flags = PyArray_mallocPyMem_RawMalloc(sizeof(npy_uint32) * len);

  if (ufunc->core_num_dims == NULL((void*)0) || ufunc->core_dim_ixs == NULL((void*)0) ||
      ufunc->core_offsets == NULL((void*)0) ||
      ufunc->core_dim_sizes == NULL((void*)0) ||
      ufunc->core_dim_flags == NULL((void*)0)) {
      PyErr_NoMemory();
      goto fail;
  }
  for (size_t j = 0; j < len; j++) {
      ufunc->core_dim_flags[j] = 0;
  }

  i = _next_non_white_space(signature, 0);
  while (signature[i] != '\0') {
      /* loop over input/output arguments */
      if (cur_arg == ufunc->nin) {
          /* expect "->" */
          if (signature[i] != '-' || signature[i+1] != '>') {
              parse_error = "expect '->'";
              goto fail;
          }
          i = _next_non_white_space(signature, i + 2);
      }

      /*
       * parse core dimensions of one argument,
       * e.g. "()", "(i)", or "(i,j)"
       */
      if (signature[i] != '(') {
          parse_error = "expect '('";
          goto fail;
      }
      i = _next_non_white_space(signature, i + 1);
      while (signature[i] != ')') {
          /* loop over core dimensions */
          int ix, i_end;
          npy_intp frozen_size;
          npy_bool can_ignore;

          if (signature[i] == '\0') {
              parse_error = "unexpected end of signature string";
              goto fail;
          }
          /*
           * Is this a variable or a fixed size dimension?
           */
          if (_is_alpha_underscore(signature[i])) {
              frozen_size = -1;
          }
          else {
              frozen_size = (npy_intp)_get_size(signature + i);
              if (frozen_size <= 0) {
                  parse_error = "expect dimension name or non-zero frozen size";
                  goto fail;
              }
          }
          /* Is this dimension flexible? */
          i_end = _get_end_of_name(signature, i);
          can_ignore = (i_end > 0 && signature[i_end - 1] == '?');
          /*
           * Determine whether we already saw this dimension name,
           * get its index, and set its properties
           */
          for(ix = 0; ix < ufunc->core_num_dim_ix; ix++) {
              if (frozen_size > 0 ?
                  frozen_size == ufunc->core_dim_sizes[ix] :
                  _is_same_name(signature + i, var_names[ix])) {
                  break;
              }
          }
          /*
           * If a new dimension, store its properties; if old, check consistency.
           */
          if (ix == ufunc->core_num_dim_ix) {
              ufunc->core_num_dim_ix++;
              var_names[ix] = signature + i;
              ufunc->core_dim_sizes[ix] = frozen_size;
              if (frozen_size < 0) {
                  ufunc->core_dim_flags[ix] |= UFUNC_CORE_DIM_SIZE_INFERRED0x0002;
              }
              if (can_ignore) {
                  ufunc->core_dim_flags[ix] |= UFUNC_CORE_DIM_CAN_IGNORE0x0004;
              }
          } else {
              if (can_ignore && !(ufunc->core_dim_flags[ix] &
                                  UFUNC_CORE_DIM_CAN_IGNORE0x0004)) {
                  parse_error = "? cannot be used, name already seen without ?";
                  goto fail;
              }
              if (!can_ignore && (ufunc->core_dim_flags[ix] &
                                  UFUNC_CORE_DIM_CAN_IGNORE0x0004)) {
                  parse_error = "? must be used, name already seen with ?";
                  goto fail;
              }
          }
          ufunc->core_dim_ixs[cur_core_dim] = ix;
          cur_core_dim++;
          nd++;
          i = _next_non_white_space(signature, i_end);
          if (signature[i] != ',' && signature[i] != ')') {
              parse_error = "expect ',' or ')'";
              goto fail;
          }
          if (signature[i] == ',')
          {
              i = _next_non_white_space(signature, i + 1);
              if (signature[i] == ')') {
                  parse_error = "',' must not be followed by ')'";
                  goto fail;
              }
          }
      }
      ufunc->core_num_dims[cur_arg] = nd;
      ufunc->core_offsets[cur_arg] = cur_core_dim-nd;
      cur_arg++;
      nd = 0;

      i = _next_non_white_space(signature, i + 1);
      if (cur_arg != ufunc->nin && cur_arg != ufunc->nargs) {
          /*
           * The list of input arguments (or output arguments) was
           * only read partially
           */
          if (signature[i] != ',') {
              parse_error = "expect ','";
              goto fail;
          }
          i = _next_non_white_space(signature, i + 1);
      }
  }
  if (cur_arg != ufunc->nargs) {
      parse_error = "incomplete signature: not all arguments found";
      goto fail;
  }
  ufunc->core_dim_ixs = PyArray_reallocPyMem_RawRealloc(ufunc->core_dim_ixs,
          sizeof(int) * cur_core_dim);
  ufunc->core_dim_sizes = PyArray_reallocPyMem_RawRealloc(
          ufunc->core_dim_sizes,
          sizeof(npy_intp) * ufunc->core_num_dim_ix);
  ufunc->core_dim_flags = PyArray_reallocPyMem_RawRealloc(
          ufunc->core_dim_flags,
          sizeof(npy_uint32) * ufunc->core_num_dim_ix);

  /* check for trivial core-signature, e.g. "(),()->()" */
  if (cur_core_dim == 0) {
      ufunc->core_enabled = 0;
  }
  PyArray_freePyMem_RawFree((void*)var_names);
  return 0;

796fail:
  PyArray_freePyMem_RawFree((void*)var_names);
  if (parse_error) {
      PyErr_Format(PyExc_ValueError,
                   "%s at position %d in \"%s\"",
                   parse_error, i, signature);
  }
  return -1;
804}

806/*
* Checks if 'obj' is a valid output array for a ufunc, i.e. it is
* either None or a writeable array, increments its reference count
* and stores a pointer to it in 'store'. Returns 0 on success, sets
* an exception and returns -1 on failure.
*/
812static int
813_set_out_array(PyObject *obj, PyArrayObject **store)
814{
  if (obj == Py_None(&_Py_NoneStruct)) {
      /* Translate None to NULL */
      return 0;
  }
  if (PyArray_Check(obj)((((PyObject*)(obj))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(obj))->ob_type), (&PyArray_Type)))) {
      /* If it's an array, store it */
      if (PyArray_FailUnlessWriteable((PyArrayObject *)obj,
                                      "output array") < 0) {
          return -1;
      }
      Py_INCREF(obj)_Py_INCREF(((PyObject*)(obj)));
      *store = (PyArrayObject *)obj;

      return 0;
  }
  PyErr_SetString(PyExc_TypeError, "return arrays must be of ArrayType");

  return -1;
833}

835/********* GENERIC UFUNC USING ITERATOR *********/

837/*
* Produce a name for the ufunc, if one is not already set
* This is used in the PyUFunc_handlefperr machinery, and in error messages
*/
841NPY_NO_EXPORT__attribute__((visibility("hidden"))) const char*
842ufunc_get_name_cstr(PyUFuncObject *ufunc) {
  return ufunc->name ? ufunc->name : "<unnamed ufunc>";
844}


847/*
* Converters for use in parsing of keywords arguments.
*/
850static int
851_subok_converter(PyObject *obj, npy_bool *subok)
852{
  if (PyBool_Check(obj)((((PyObject*)(obj))->ob_type) == &PyBool_Type)) {
      *subok = (obj == Py_True((PyObject *) &_Py_TrueStruct));
      return NPY_SUCCEED1;
  }
  else {
      PyErr_SetString(PyExc_TypeError,
                      "'subok' must be a boolean");
      return NPY_FAIL0;
  }
862}

864static int
865_keepdims_converter(PyObject *obj, int *keepdims)
866{
  if (PyBool_Check(obj)((((PyObject*)(obj))->ob_type) == &PyBool_Type)) {
      *keepdims = (obj == Py_True((PyObject *) &_Py_TrueStruct));
      return NPY_SUCCEED1;
  }
  else {
      PyErr_SetString(PyExc_TypeError,
                      "'keepdims' must be a boolean");
      return NPY_FAIL0;
  }
876}

878static int
879_wheremask_converter(PyObject *obj, PyArrayObject **wheremask)
880{
  /*
   * Optimization: where=True is the same as no where argument.
   * This lets us document True as the default.
   */
  if (obj == Py_True((PyObject *) &_Py_TrueStruct)) {
      return NPY_SUCCEED1;
  }
  else {
      PyArray_Descr *dtype = PyArray_DescrFromType(NPY_BOOL);
      if (dtype == NULL((void*)0)) {
          return NPY_FAIL0;
      }
      /* PyArray_FromAny steals reference to dtype, even on failure */
      *wheremask = (PyArrayObject *)PyArray_FromAny(obj, dtype, 0, 0, 0, NULL((void*)0));
      if ((*wheremask) == NULL((void*)0)) {
          return NPY_FAIL0;
      }
      return NPY_SUCCEED1;
  }
900}


903/*
* Due to the array override, do the actual parameter conversion
* only in this step. This function takes the reference objects and
* parses them into the desired values.
* This function cleans up after itself and NULLs references on error,
* however, the caller has to ensure that `out_op[0:nargs]` and `out_whermeask`
* are NULL initialized.
*/
911static int
912convert_ufunc_arguments(PyUFuncObject *ufunc,
      ufunc_full_args full_args, PyArrayObject **out_op,
      PyObject *order_obj, NPY_ORDER *out_order,
      PyObject *casting_obj, NPY_CASTING *out_casting,
      PyObject *subok_obj, npy_bool *out_subok,
      PyObject *where_obj, PyArrayObject **out_wheremask, /* PyArray of bool */
      PyObject *keepdims_obj, int *out_keepdims)
919{
  int nin = ufunc->nin;
  int nout = ufunc->nout;
  int nop = ufunc->nargs;
  PyObject *obj;

  /* Convert and fill in input arguments */
  for (int i = 0; i < nin; i++) {
      obj = PyTuple_GET_ITEM(full_args.in, i)((((void) (0)), (PyTupleObject *)(full_args.in))->ob_item[
i]);

      if (PyArray_Check(obj)((((PyObject*)(obj))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(obj))->ob_type), (&PyArray_Type)))) {
          PyArrayObject *obj_a = (PyArrayObject *)obj;
          out_op[i] = (PyArrayObject *)PyArray_FromArray(obj_a, NULL((void*)0), 0);
      }
      else {
          out_op[i] = (PyArrayObject *)PyArray_FromAny(obj,
                                  NULL((void*)0), 0, 0, 0, NULL((void*)0));
      }

      if (out_op[i] == NULL((void*)0)) {
          goto fail;
      }
  }

  /* Convert and fill in output arguments */
  if (full_args.out != NULL((void*)0)) {
      for (int i = 0; i < nout; i++) {
          obj = PyTuple_GET_ITEM(full_args.out, i)((((void) (0)), (PyTupleObject *)(full_args.out))->ob_item
[i]);
          if (_set_out_array(obj, out_op + i + nin) < 0) {
              goto fail;
          }
      }
  }

  /*
   * Convert most arguments manually here, since it is easier to handle
   * the ufunc override if we first parse only to objects.
   */
  if (where_obj && !_wheremask_converter(where_obj, out_wheremask)) {
      goto fail;
  }
  if (keepdims_obj && !_keepdims_converter(keepdims_obj, out_keepdims)) {
      goto fail;
  }
  if (casting_obj && !PyArray_CastingConverter(casting_obj, out_casting)) {
      goto fail;
  }
  if (order_obj && !PyArray_OrderConverter(order_obj, out_order)) {
      goto fail;
  }
  if (subok_obj && !_subok_converter(subok_obj, out_subok)) {
      goto fail;
  }
  return 0;

974fail:
  if (out_wheremask != NULL((void*)0)) {
      Py_XSETREF(*out_wheremask, NULL)do { PyObject *_py_tmp = ((PyObject*)(*out_wheremask)); (*out_wheremask
) = (((void*)0)); _Py_XDECREF(((PyObject*)(_py_tmp))); } while
 (0);
  }
  for (int i = 0; i < nop; i++) {
      Py_XSETREF(out_op[i], NULL)do { PyObject *_py_tmp = ((PyObject*)(out_op[i])); (out_op[i]
) = (((void*)0)); _Py_XDECREF(((PyObject*)(_py_tmp))); } while
 (0);
  }
  return -1;
982}

984/*
* This checks whether a trivial loop is ok,
* making copies of scalar and one dimensional operands if that will
* help.
*
* Returns 1 if a trivial loop is ok, 0 if it is not, and
* -1 if there is an error.
*/
992static int
993check_for_trivial_loop(PyUFuncObject *ufunc,
                      PyArrayObject **op,
                      PyArray_Descr **dtype,
                      npy_intp buffersize)
997{
  npy_intp i, nin = ufunc->nin, nop = nin + ufunc->nout;

  for (i = 0; i < nop; ++i) {
      /*
       * If the dtype doesn't match, or the array isn't aligned,
       * indicate that the trivial loop can't be done.
       */
      if (op[i] != NULL((void*)0) &&
              (!PyArray_ISALIGNED(op[i])PyArray_CHKFLAGS((op[i]), 0x0100) ||
              !PyArray_EquivTypes(dtype[i], PyArray_DESCR(op[i]))
                                      )) {
          /*
           * If op[j] is a scalar or small one dimensional
           * array input, make a copy to keep the opportunity
           * for a trivial loop.
           */
          if (i < nin && (PyArray_NDIM(op[i]) == 0 ||
                  (PyArray_NDIM(op[i]) == 1 &&
                   PyArray_DIM(op[i],0) <= buffersize))) {
              PyArrayObject *tmp;
              Py_INCREF(dtype[i])_Py_INCREF(((PyObject*)(dtype[i])));
              tmp = (PyArrayObject *)
                          PyArray_CastToType(op[i], dtype[i], 0);
              if (tmp == NULL((void*)0)) {
                  return -1;
              }
              Py_DECREF(op[i])_Py_DECREF(((PyObject*)(op[i])));
              op[i] = tmp;
          }
          else {
              return 0;
          }
      }
  }

  return 1;
1034}


1037/*
* Calls the given __array_prepare__ function on the operand *op,
* substituting it in place if a new array is returned and matches
* the old one.
*
* This requires that the dimensions, strides and data type remain
* exactly the same, which may be more strict than before.
*/
1045static int
1046prepare_ufunc_output(PyUFuncObject *ufunc,
                  PyArrayObject **op,
                  PyObject *arr_prep,
                  ufunc_full_args full_args,
                  int i)
1051{
  if (arr_prep != NULL((void*)0) && arr_prep != Py_None(&_Py_NoneStruct)) {
      PyObject *res;
      PyArrayObject *arr;
      PyObject *args_tup;

      /* Call with the context argument */
      args_tup = _get_wrap_prepare_args(full_args);
      if (args_tup == NULL((void*)0)) {
          return -1;
      }
      res = PyObject_CallFunction(
          arr_prep, "O(OOi)", *op, ufunc, args_tup, i);
      Py_DECREF(args_tup)_Py_DECREF(((PyObject*)(args_tup)));

      if (res == NULL((void*)0)) {
          return -1;
      }
      else if (!PyArray_Check(res)((((PyObject*)(res))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(res))->ob_type), (&PyArray_Type)))) {
          PyErr_SetString(PyExc_TypeError,
                  "__array_prepare__ must return an "
                  "ndarray or subclass thereof");
          Py_DECREF(res)_Py_DECREF(((PyObject*)(res)));
          return -1;
      }
      arr = (PyArrayObject *)res;

      /* If the same object was returned, nothing to do */
      if (arr == *op) {
          Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
      }
      /* If the result doesn't match, throw an error */
      else if (PyArray_NDIM(arr) != PyArray_NDIM(*op) ||
              !PyArray_CompareLists(PyArray_DIMS(arr),
                                    PyArray_DIMS(*op),
                                    PyArray_NDIM(arr)) ||
              !PyArray_CompareLists(PyArray_STRIDES(arr),
                                    PyArray_STRIDES(*op),
                                    PyArray_NDIM(arr)) ||
              !PyArray_EquivTypes(PyArray_DESCR(arr),
                                  PyArray_DESCR(*op))) {
          PyErr_SetString(PyExc_TypeError,
                  "__array_prepare__ must return an "
                  "ndarray or subclass thereof which is "
                  "otherwise identical to its input");
          Py_DECREF(arr)_Py_DECREF(((PyObject*)(arr)));
          return -1;
      }
      /* Replace the op value */
      else {
          Py_DECREF(*op)_Py_DECREF(((PyObject*)(*op)));
          *op = arr;
      }
  }

  return 0;
1107}


1110/*
* Check whether a trivial loop is possible and call the innerloop if it is.
* A trivial loop is defined as one where a single strided inner-loop call
* is possible.
*
* This function only supports a single output (due to the overlap check).
* It always accepts 0-D arrays and will broadcast them.  The function
* cannot broadcast any other array (as it requires a single stride).
* The function accepts all 1-D arrays, and N-D arrays that are either all
* C- or all F-contiguous.
*
* Returns -2 if a trivial loop is not possible, 0 on success and -1 on error.
*/
1123static NPY_INLINEinline int
1124try_trivial_single_output_loop(PyUFuncObject *ufunc,
      PyArrayObject *op[], PyArray_Descr *dtypes[],
      NPY_ORDER order, PyObject *arr_prep[], ufunc_full_args full_args,
      PyUFuncGenericFunction innerloop, void *innerloopdata)
1128{
  int nin = ufunc->nin;
  int nop = nin + 1;
  assert(ufunc->nout == 1)((void) (0));

  /* The order of all N-D contiguous operands, can be fixed by `order` */
  int operation_order = 0;
  if (order == NPY_CORDER) {
      operation_order = NPY_ARRAY_C_CONTIGUOUS0x0001;
  }
  else if (order == NPY_FORTRANORDER) {
      operation_order = NPY_ARRAY_F_CONTIGUOUS0x0002;
  }

  int operation_ndim = 0;
  npy_intp *operation_shape = NULL((void*)0);
  npy_intp fixed_strides[NPY_MAXARGS32];

  for (int iop = 0; iop < nop; iop++) {
      if (op[iop] == NULL((void*)0)) {
          /* The out argument may be NULL (and only that one); fill later */
          assert(iop == nin)((void) (0));
          continue;
      }

      int op_ndim = PyArray_NDIM(op[iop]);

      /* Special case 0-D since we can handle broadcasting using a 0-stride */
      if (op_ndim == 0) {
          fixed_strides[iop] = 0;
          continue;
      }

      /* First non 0-D op: fix dimensions, shape (order is fixed later) */
      if (operation_ndim == 0) {
          operation_ndim = op_ndim;
          operation_shape = PyArray_SHAPE(op[iop]);
      }
      else if (op_ndim != operation_ndim) {
          return -2;  /* dimension mismatch (except 0-d ops) */
      }
      else if (!PyArray_CompareLists(
              operation_shape, PyArray_DIMS(op[iop]), op_ndim)) {
          return -2;  /* shape mismatch */
      }

      if (op_ndim == 1) {
          fixed_strides[iop] = PyArray_STRIDES(op[iop])[0];
      }
      else {
          fixed_strides[iop] = PyArray_ITEMSIZE(op[iop]);  /* contiguous */

          /* This op must match the operation order (and be contiguous) */
          int op_order = (PyArray_FLAGS(op[iop]) &
                          (NPY_ARRAY_C_CONTIGUOUS0x0001|NPY_ARRAY_F_CONTIGUOUS0x0002));
          if (op_order == 0) {
              return -2;  /* N-dimensional op must be contiguous */
          }
          else if (operation_order == 0) {
              operation_order = op_order;  /* op fixes order */
          }
          else if (operation_order != op_order) {
              return -2;
          }
      }
  }

  if (op[nin] == NULL((void*)0)) {
      Py_INCREF(dtypes[nin])_Py_INCREF(((PyObject*)(dtypes[nin])));
      op[nin] = (PyArrayObject *) PyArray_NewFromDescr(&PyArray_Type,
              dtypes[nin], operation_ndim, operation_shape,
              NULL((void*)0), NULL((void*)0), operation_order==NPY_ARRAY_F_CONTIGUOUS0x0002, NULL((void*)0));
      if (op[nin] == NULL((void*)0)) {
          return -1;
      }
      fixed_strides[nin] = dtypes[nin]->elsize;
  }
  else {
      /* If any input overlaps with the output, we use the full path. */
      for (int iop = 0; iop < nin; iop++) {
          if (!PyArray_EQUIVALENTLY_ITERABLE_OVERLAP_OK(
                  op[iop], op[nin],
                  PyArray_TRIVIALLY_ITERABLE_OP_READ1,
                  PyArray_TRIVIALLY_ITERABLE_OP_NOREAD0)) {
              return -2;
          }
      }
      /* Check self-overlap (non 1-D are contiguous, perfect overlap is OK) */
      if (operation_ndim == 1 &&
              PyArray_STRIDES(op[nin])[0] < PyArray_ITEMSIZE(op[nin]) &&
              PyArray_STRIDES(op[nin])[0] != 0) {
          return -2;
      }
  }

  /* Call the __prepare_array__ if necessary */
  if (prepare_ufunc_output(ufunc, &op[nin],
          arr_prep[0], full_args, 0) < 0) {
      return -1;
  }

  /*
   * We can use the trivial (single inner-loop call) optimization
   * and `fixed_strides` holds the strides for that call.
   */
  char *data[NPY_MAXARGS32];
  npy_intp count = PyArray_MultiplyList(operation_shape, operation_ndim);
  int needs_api = 0;
  NPY_BEGIN_THREADS_DEFPyThreadState *_save=((void*)0);;

  for (int iop = 0; iop < nop; iop++) {
      data[iop] = PyArray_BYTES(op[iop]);
      needs_api |= PyDataType_REFCHK(dtypes[iop])(((dtypes[iop])->flags & (0x01)) == (0x01));
  }

  if (!needs_api) {
      NPY_BEGIN_THREADS_THRESHOLDED(count)do { if ((count) > 500) { _save = PyEval_SaveThread();} } while
 (0);;
  }

  innerloop(data, &count, fixed_strides, innerloopdata);

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


1254static int
1255iterator_loop(PyUFuncObject *ufunc,
                  PyArrayObject **op,
                  PyArray_Descr **dtype,
                  NPY_ORDER order,
                  npy_intp buffersize,
                  PyObject **arr_prep,
                  ufunc_full_args full_args,
                  PyUFuncGenericFunction innerloop,
                  void *innerloopdata,
                  npy_uint32 *op_flags)
1265{
  npy_intp i, nin = ufunc->nin, nout = ufunc->nout;
  npy_intp nop = nin + nout;
  NpyIter *iter;
  char *baseptrs[NPY_MAXARGS32];

  NpyIter_IterNextFunc *iternext;
  char **dataptr;
  npy_intp *stride;
  npy_intp *count_ptr;
  int needs_api;

  PyArrayObject **op_it;
  npy_uint32 iter_flags;

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

  iter_flags = ufunc->iter_flags |
               NPY_ITER_EXTERNAL_LOOP0x00000008 |
               NPY_ITER_REFS_OK0x00000020 |
               NPY_ITER_ZEROSIZE_OK0x00000040 |
               NPY_ITER_BUFFERED0x00000200 |
               NPY_ITER_GROWINNER0x00000400 |
               NPY_ITER_DELAY_BUFALLOC0x00000800 |
               NPY_ITER_COPY_IF_OVERLAP0x00002000;

  /* Call the __array_prepare__ functions for already existing output arrays.
   * Do this before creating the iterator, as the iterator may UPDATEIFCOPY
   * some of them.
   */
  for (i = 0; i < nout; ++i) {
      if (op[nin+i] == NULL((void*)0)) {
          continue;
      }
      if (prepare_ufunc_output(ufunc, &op[nin+i],
                          arr_prep[i], full_args, i) < 0) {
          return -1;
      }
  }

  /*
   * Allocate the iterator.  Because the types of the inputs
   * were already checked, we use the casting rule 'unsafe' which
   * is faster to calculate.
   */
  iter = NpyIter_AdvancedNew(nop, op,
                      iter_flags,
                      order, NPY_UNSAFE_CASTING,
                      op_flags, dtype,
                      -1, NULL((void*)0), NULL((void*)0), buffersize);
  if (iter == NULL((void*)0)) {
      return -1;
  }

  /* Copy any allocated outputs */
  op_it = NpyIter_GetOperandArray(iter);
  for (i = 0; i < nout; ++i) {
      if (op[nin+i] == NULL((void*)0)) {
          op[nin+i] = op_it[nin+i];
          Py_INCREF(op[nin+i])_Py_INCREF(((PyObject*)(op[nin+i])));

          /* Call the __array_prepare__ functions for the new array */
          if (prepare_ufunc_output(ufunc, &op[nin+i],
                                   arr_prep[i], full_args, i) < 0) {
              NpyIter_Deallocate(iter);
              return -1;
          }

          /*
           * In case __array_prepare__ returned a different array, put the
           * results directly there, ignoring the array allocated by the
           * iterator.
           *
           * Here, we assume the user-provided __array_prepare__ behaves
           * sensibly and doesn't return an array overlapping in memory
           * with other operands --- the op[nin+i] array passed to it is newly
           * allocated and doesn't have any overlap.
           */
          baseptrs[nin+i] = PyArray_BYTES(op[nin+i]);
      }
      else {
          baseptrs[nin+i] = PyArray_BYTES(op_it[nin+i]);
      }
  }

  /* Only do the loop if the iteration size is non-zero */
  if (NpyIter_GetIterSize(iter) != 0) {
      /* Reset the iterator with the base pointers from possible __array_prepare__ */
      for (i = 0; i < nin; ++i) {
          baseptrs[i] = PyArray_BYTES(op_it[i]);
      }
      if (NpyIter_ResetBasePointers(iter, baseptrs, NULL((void*)0)) != NPY_SUCCEED1) {
          NpyIter_Deallocate(iter);
          return -1;
      }

      /* Get the variables needed for the loop */
      iternext = NpyIter_GetIterNext(iter, NULL((void*)0));
      if (iternext == NULL((void*)0)) {
          NpyIter_Deallocate(iter);
          return -1;
      }
      dataptr = NpyIter_GetDataPtrArray(iter);
      stride = NpyIter_GetInnerStrideArray(iter);
      count_ptr = NpyIter_GetInnerLoopSizePtr(iter);
      needs_api = NpyIter_IterationNeedsAPI(iter);

      NPY_BEGIN_THREADS_NDITER(iter)do { if (!NpyIter_IterationNeedsAPI(iter)) { do { if ((NpyIter_GetIterSize
(iter)) > 500) { _save = PyEval_SaveThread();} } while (0)
;; } } while(0);

      /* Execute the loop */
      do {
          NPY_UF_DBG_PRINT1("iterator loop count %d\n", (int)*count_ptr);
          innerloop(dataptr, count_ptr, stride, innerloopdata);
      } while (!(needs_api && PyErr_Occurred()) && iternext(iter));

      NPY_END_THREADSdo { if (_save) { PyEval_RestoreThread(_save); _save = ((void
*)0);} } while (0);;
  }
  /*
   * Currently `innerloop` may leave an error set, in this case
   * NpyIter_Deallocate will always return an error as well.
   */
  if (NpyIter_Deallocate(iter) == NPY_FAIL0) {
      return -1;
  }
  return 0;
1390}

1392/*
* ufunc           - the ufunc to call
* trivial_loop_ok - 1 if no alignment, data conversion, etc required
* op              - the operands (ufunc->nin + ufunc->nout of them)
* dtypes          - the dtype of each operand
* order           - the loop execution order/output memory order
* buffersize      - how big of a buffer to use
* arr_prep        - the __array_prepare__ functions for the outputs
* full_args       - the original input, output PyObject *
* op_flags        - per-operand flags, a combination of NPY_ITER_* constants
*/
1403static int
1404execute_legacy_ufunc_loop(PyUFuncObject *ufunc,
                  int trivial_loop_ok,
                  PyArrayObject **op,
                  PyArray_Descr **dtypes,
                  NPY_ORDER order,
                  npy_intp buffersize,
                  PyObject **arr_prep,
                  ufunc_full_args full_args,
                  npy_uint32 *op_flags)
1413{
  PyUFuncGenericFunction innerloop;
  void *innerloopdata;
  int needs_api = 0;

  if (ufunc->legacy_inner_loop_selector(ufunc, dtypes,
                  &innerloop, &innerloopdata, &needs_api) < 0) {
      return -1;
  }

  /* First check for the trivial cases that don't need an iterator */
  if (trivial_loop_ok && ufunc->nout == 1) {
      int fast_path_result = try_trivial_single_output_loop(ufunc,
              op, dtypes, order, arr_prep, full_args,
              innerloop, innerloopdata);
      if (fast_path_result != -2) {
          return fast_path_result;
      }
  }

  /*
   * If no trivial loop matched, an iterator is required to
   * resolve broadcasting, etc
   */
  NPY_UF_DBG_PRINT("iterator loop\n");
  if (iterator_loop(ufunc, op, dtypes, order,
                  buffersize, arr_prep, full_args,
                  innerloop, innerloopdata, op_flags) < 0) {
      return -1;
  }

  return 0;
1445}

1447/*
* nin             - number of inputs
* nout            - number of outputs
* wheremask       - if not NULL, the 'where=' parameter to the ufunc.
* op              - the operands (nin + nout of them)
* order           - the loop execution order/output memory order
* buffersize      - how big of a buffer to use
* arr_prep        - the __array_prepare__ functions for the outputs
* innerloop       - the inner loop function
* innerloopdata   - data to pass to the inner loop
*/
1458static int
1459execute_fancy_ufunc_loop(PyUFuncObject *ufunc,
                  PyArrayObject *wheremask,
                  PyArrayObject **op,
                  PyArray_Descr **dtypes,
                  NPY_ORDER order,
                  npy_intp buffersize,
                  PyObject **arr_prep,
                  ufunc_full_args full_args,
                  npy_uint32 *op_flags)
1468{
  int i, nin = ufunc->nin, nout = ufunc->nout;
  int nop = nin + nout;
  NpyIter *iter;
  int needs_api;

  NpyIter_IterNextFunc *iternext;
  char **dataptr;
  npy_intp *strides;
  npy_intp *countptr;

  PyArrayObject **op_it;
  npy_uint32 iter_flags;

  for (i = nin; i < nop; ++i) {
1
Assuming 'i' is < 'nop'→
2
←
Loop condition is true.  Entering loop body→
5
←
Assuming 'i' is >= 'nop'→
6
←
Loop condition is false. Execution continues on line 1486→
      op_flags[i] |= (op[i] != NULL((void*)0) ? NPY_ITER_READWRITE0x00010000 : NPY_ITER_WRITEONLY0x00040000);
3
←
Assuming the condition is false→
4
←
'?' condition is false→
  }

  if (wheremask != NULL((void*)0)) {
7
←
Assuming 'wheremask' is equal to NULL→
8
←
Taking false branch→
      op_flags[nop] = NPY_ITER_READONLY0x00020000 | NPY_ITER_ARRAYMASK0x20000000;
  }

  NPY_UF_DBG_PRINT("Making iterator\n");

  iter_flags = ufunc->iter_flags |
               NPY_ITER_EXTERNAL_LOOP0x00000008 |
               NPY_ITER_REFS_OK0x00000020 |
               NPY_ITER_ZEROSIZE_OK0x00000040 |
               NPY_ITER_BUFFERED0x00000200 |
               NPY_ITER_GROWINNER0x00000400 |
               NPY_ITER_COPY_IF_OVERLAP0x00002000;

  /*
   * Allocate the iterator.  Because the types of the inputs
   * were already checked, we use the casting rule 'unsafe' which
   * is faster to calculate.
   */
  iter = NpyIter_AdvancedNew(nop + ((wheremask8.1
'wheremask' is equal to NULL
1
'wheremask' is equal to NULL
 != NULL((void*)0)) ? 1 : 0), op,
9
←
'?' condition is false→
                      iter_flags,
                      order, NPY_UNSAFE_CASTING,
                      op_flags, dtypes,
                      -1, NULL((void*)0), NULL((void*)0), buffersize);
  if (iter == NULL((void*)0)) {
10
←
Assuming 'iter' is not equal to NULL→
11
←
Taking false branch→
      return -1;
  }

  NPY_UF_DBG_PRINT("Made iterator\n");

  needs_api = NpyIter_IterationNeedsAPI(iter);

  /* Call the __array_prepare__ functions where necessary */
  op_it = NpyIter_GetOperandArray(iter);
  for (i = nin; i11.1
'i' is < 'nop'
1
'i' is < 'nop'
 < nop; ++i) {
12
←
Loop condition is true.  Entering loop body→
      PyArrayObject *op_tmp, *orig_op_tmp;

      /*
       * The array can be allocated by the iterator -- it is placed in op[i]
       * and returned to the caller, and this needs an extra incref.
       */
      if (op[i] == NULL((void*)0)) {
13
←
Assuming the condition is false→
14
←
Taking false branch→
          op_tmp = op_it[i];
          Py_INCREF(op_tmp)_Py_INCREF(((PyObject*)(op_tmp)));
      }
      else {
          op_tmp = op[i];
19
←
PyObject ownership leak with reference count of 1
      }

      /* prepare_ufunc_output may decref & replace the pointer */
      orig_op_tmp = op_tmp;
      Py_INCREF(op_tmp)_Py_INCREF(((PyObject*)(op_tmp)));
15
←
Calling '_Py_INCREF'→
17
←
Returning from '_Py_INCREF'→

      if (prepare_ufunc_output(ufunc, &op_tmp,
18
←
Taking true branch→
                               arr_prep[i], full_args, i) < 0) {
          NpyIter_Deallocate(iter);
          return -1;
      }

      /* Validate that the prepare_ufunc_output didn't mess with pointers */
      if (PyArray_BYTES(op_tmp) != PyArray_BYTES(orig_op_tmp)) {
          PyErr_SetString(PyExc_ValueError,
                      "The __array_prepare__ functions modified the data "
                      "pointer addresses in an invalid fashion");
          Py_DECREF(op_tmp)_Py_DECREF(((PyObject*)(op_tmp)));
          NpyIter_Deallocate(iter);
          return -1;
      }

      /*
       * Put the updated operand back and undo the DECREF above. If
       * COPY_IF_OVERLAP made a temporary copy, the output will be copied
       * by UPDATEIFCOPY even if op[i] was changed by prepare_ufunc_output.
       */
      op[i] = op_tmp;
      Py_DECREF(op_tmp)_Py_DECREF(((PyObject*)(op_tmp)));
  }

  /* Only do the loop if the iteration size is non-zero */
  if (NpyIter_GetIterSize(iter) != 0) {
      PyUFunc_MaskedStridedInnerLoopFunc *innerloop;
      NpyAuxData *innerloopdata;
      npy_intp fixed_strides[2*NPY_MAXARGS32];
      PyArray_Descr **iter_dtypes;
      NPY_BEGIN_THREADS_DEFPyThreadState *_save=((void*)0);;

      /*
       * Get the inner loop, with the possibility of specialization
       * based on the fixed strides.
       */
      NpyIter_GetInnerFixedStrideArray(iter, fixed_strides);
      iter_dtypes = NpyIter_GetDescrArray(iter);
      if (ufunc->masked_inner_loop_selector(ufunc, dtypes,
                      wheremask != NULL((void*)0) ? iter_dtypes[nop]
                                        : iter_dtypes[nop + nin],
                      fixed_strides,
                      wheremask != NULL((void*)0) ? fixed_strides[nop]
                                        : fixed_strides[nop + nin],
                      &innerloop, &innerloopdata, &needs_api) < 0) {
          NpyIter_Deallocate(iter);
          return -1;
      }

      /* Get the variables needed for the loop */
      iternext = NpyIter_GetIterNext(iter, NULL((void*)0));
      if (iternext == NULL((void*)0)) {
          NpyIter_Deallocate(iter);
          return -1;
      }
      dataptr = NpyIter_GetDataPtrArray(iter);
      strides = NpyIter_GetInnerStrideArray(iter);
      countptr = NpyIter_GetInnerLoopSizePtr(iter);
      needs_api = NpyIter_IterationNeedsAPI(iter);

      NPY_BEGIN_THREADS_NDITER(iter)do { if (!NpyIter_IterationNeedsAPI(iter)) { do { if ((NpyIter_GetIterSize
(iter)) > 500) { _save = PyEval_SaveThread();} } while (0)
;; } } while(0);

      NPY_UF_DBG_PRINT("Actual inner loop:\n");
      /* Execute the loop */
      do {
          NPY_UF_DBG_PRINT1("iterator loop count %d\n", (int)*countptr);
          innerloop(dataptr, strides,
                      dataptr[nop], strides[nop],
                      *countptr, innerloopdata);
      } while (!(needs_api && PyErr_Occurred()) && iternext(iter));

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

      NPY_AUXDATA_FREE(innerloopdata)do { if ((innerloopdata) != ((void*)0)) { (innerloopdata)->
free(innerloopdata); } } while(0);
  }

  return NpyIter_Deallocate(iter);
1617}


1620/*
* Validate that operands have enough dimensions, accounting for
* possible flexible dimensions that may be absent.
*/
1624static int
1625_validate_num_dims(PyUFuncObject *ufunc, PyArrayObject **op,
                 npy_uint32 *core_dim_flags,
                 int *op_core_num_dims) {
  int i, j;
  int nin = ufunc->nin;
  int nop = ufunc->nargs;

  for (i = 0; i < nop; i++) {
      if (op[i] != NULL((void*)0)) {
          int op_ndim = PyArray_NDIM(op[i]);

          if (op_ndim < op_core_num_dims[i]) {
              int core_offset = ufunc->core_offsets[i];
              /* We've too few, but some dimensions might be flexible */
              for (j = core_offset;
                   j < core_offset + ufunc->core_num_dims[i]; j++) {
                  int core_dim_index = ufunc->core_dim_ixs[j];
                  if ((core_dim_flags[core_dim_index] &
                       UFUNC_CORE_DIM_CAN_IGNORE0x0004)) {
                      int i1, j1, k;
                      /*
                       * Found a dimension that can be ignored. Flag that
                       * it is missing, and unflag that it can be ignored,
                       * since we are doing so already.
                       */
                      core_dim_flags[core_dim_index] |= UFUNC_CORE_DIM_MISSING0x00040000;
                      core_dim_flags[core_dim_index] ^= UFUNC_CORE_DIM_CAN_IGNORE0x0004;
                      /*
                       * Reduce the number of core dimensions for all
                       * operands that use this one (including ours),
                       * and check whether we're now OK.
                       */
                      for (i1 = 0, k=0; i1 < nop; i1++) {
                          for (j1 = 0; j1 < ufunc->core_num_dims[i1]; j1++) {
                              if (ufunc->core_dim_ixs[k++] == core_dim_index) {
                                  op_core_num_dims[i1]--;
                              }
                          }
                      }
                      if (op_ndim == op_core_num_dims[i]) {
                          break;
                      }
                  }
              }
              if (op_ndim < op_core_num_dims[i]) {
                  PyErr_Format(PyExc_ValueError,
                       "%s: %s operand %d does not have enough "
                       "dimensions (has %d, gufunc core with "
                       "signature %s requires %d)",
                       ufunc_get_name_cstr(ufunc),
                       i < nin ? "Input" : "Output",
                       i < nin ? i : i - nin, PyArray_NDIM(op[i]),
                       ufunc->core_signature, op_core_num_dims[i]);
                  return -1;
              }
          }
      }
  }
  return 0;
1684}

1686/*
* Check whether any of the outputs of a gufunc has core dimensions.
*/
1689static int
1690_has_output_coredims(PyUFuncObject *ufunc) {
  int i;
  for (i = ufunc->nin; i < ufunc->nin + ufunc->nout; ++i) {
      if (ufunc->core_num_dims[i] > 0) {
          return 1;
      }
  }
  return 0;
1698}

1700/*
* Check whether the gufunc can be used with axis, i.e., that there is only
* a single, shared core dimension (which means that operands either have
* that dimension, or have no core dimensions).  Returns 0 if all is fine,
* and sets an error and returns -1 if not.
*/
1706static int
1707_check_axis_support(PyUFuncObject *ufunc) {
  if (ufunc->core_num_dim_ix != 1) {
      PyErr_Format(PyExc_TypeError,
                   "%s: axis can only be used with a single shared core "
                   "dimension, not with the %d distinct ones implied by "
                   "signature %s.",
                   ufunc_get_name_cstr(ufunc),
                   ufunc->core_num_dim_ix,
                   ufunc->core_signature);
      return -1;
  }
  return 0;
1719}

1721/*
* Check whether the gufunc can be used with keepdims, i.e., that all its
* input arguments have the same number of core dimension, and all output
* arguments have no core dimensions. Returns 0 if all is fine, and sets
* an error and returns -1 if not.
*/
1727static int
1728_check_keepdims_support(PyUFuncObject *ufunc) {
  int i;
  int nin = ufunc->nin, nout = ufunc->nout;
  int input_core_dims = ufunc->core_num_dims[0];
  for (i = 1; i < nin + nout; i++) {
      if (ufunc->core_num_dims[i] != (i < nin ? input_core_dims : 0)) {
          PyErr_Format(PyExc_TypeError,
              "%s does not support keepdims: its signature %s requires "
              "%s %d to have %d core dimensions, but keepdims can only "
              "be used when all inputs have the same number of core "
              "dimensions and all outputs have no core dimensions.",
              ufunc_get_name_cstr(ufunc),
              ufunc->core_signature,
              i < nin ? "input" : "output",
              i < nin ? i : i - nin,
              ufunc->core_num_dims[i]);
          return -1;
      }
  }
  return 0;
1748}

1750/*
* Interpret a possible axes keyword argument, using it to fill the remap_axis
* array which maps default to actual axes for each operand, indexed as
* as remap_axis[iop][iaxis]. The default axis order has first all broadcast
* axes and then the core axes the gufunc operates on.
*
* Returns 0 on success, and -1 on failure
*/
1758static int
1759_parse_axes_arg(PyUFuncObject *ufunc, int op_core_num_dims[], PyObject *axes,
              PyArrayObject **op, int broadcast_ndim, int **remap_axis) {
  int nin = ufunc->nin;
  int nop = ufunc->nargs;
  int iop, list_size;

  if (!PyList_Check(axes)((((((PyObject*)(axes))->ob_type))->tp_flags & ((1UL
 << 25))) != 0)) {
      PyErr_SetString(PyExc_TypeError, "axes should be a list.");
      return -1;
  }
  list_size = PyList_Size(axes);
  if (list_size != nop) {
      if (list_size != nin || _has_output_coredims(ufunc)) {
          PyErr_Format(PyExc_ValueError,
                       "axes should be a list with an entry for all "
                       "%d inputs and outputs; entries for outputs can only "
                       "be omitted if none of them has core axes.",
                       nop);
          return -1;
      }
      for (iop = nin; iop < nop; iop++) {
          remap_axis[iop] = NULL((void*)0);
      }
  }
  for (iop = 0; iop < list_size; ++iop) {
      int op_ndim, op_ncore, op_nbroadcast;
      int have_seen_axis[NPY_MAXDIMS32] = {0};
      PyObject *op_axes_tuple, *axis_item;
      int axis, op_axis;

      op_ncore = op_core_num_dims[iop];
      if (op[iop] != NULL((void*)0)) {
          op_ndim = PyArray_NDIM(op[iop]);
          op_nbroadcast = op_ndim - op_ncore;
      }
      else {
          op_nbroadcast = broadcast_ndim;
          op_ndim = broadcast_ndim + op_ncore;
      }
      /*
       * Get axes tuple for operand. If not a tuple already, make it one if
       * there is only one axis (its content is checked later).
       */
      op_axes_tuple = PyList_GET_ITEM(axes, iop)(((PyListObject *)(axes))->ob_item[iop]);
      if (PyTuple_Check(op_axes_tuple)((((((PyObject*)(op_axes_tuple))->ob_type))->tp_flags &
 ((1UL << 26))) != 0)) {
          if (PyTuple_Size(op_axes_tuple) != op_ncore) {
              if (op_ncore == 1) {
                  PyErr_Format(PyExc_ValueError,
                               "axes item %d should be a tuple with a "
                               "single element, or an integer", iop);
              }
              else {
                  PyErr_Format(PyExc_ValueError,
                               "axes item %d should be a tuple with %d "
                               "elements", iop, op_ncore);
              }
              return -1;
          }
          Py_INCREF(op_axes_tuple)_Py_INCREF(((PyObject*)(op_axes_tuple)));
      }
      else if (op_ncore == 1) {
          op_axes_tuple = PyTuple_Pack(1, op_axes_tuple);
          if (op_axes_tuple == NULL((void*)0)) {
              return -1;
          }
      }
      else {
          PyErr_Format(PyExc_TypeError, "axes item %d should be a tuple",
                       iop);
          return -1;
      }
      /*
       * Now create the remap, starting with the core dimensions, and then
       * adding the remaining broadcast axes that are to be iterated over.
       */
      for (axis = op_nbroadcast; axis < op_ndim; axis++) {
          axis_item = PyTuple_GET_ITEM(op_axes_tuple, axis - op_nbroadcast)((((void) (0)), (PyTupleObject *)(op_axes_tuple))->ob_item
[axis - op_nbroadcast]);
          op_axis = PyArray_PyIntAsInt(axis_item);
          if (error_converting(op_axis)(((op_axis) == -1) && PyErr_Occurred()) ||
                  (check_and_adjust_axis(&op_axis, op_ndim) < 0)) {
              Py_DECREF(op_axes_tuple)_Py_DECREF(((PyObject*)(op_axes_tuple)));
              return -1;
          }
          if (have_seen_axis[op_axis]) {
              PyErr_Format(PyExc_ValueError,
                           "axes item %d has value %d repeated",
                           iop, op_axis);
              Py_DECREF(op_axes_tuple)_Py_DECREF(((PyObject*)(op_axes_tuple)));
              return -1;
          }
          have_seen_axis[op_axis] = 1;
          remap_axis[iop][axis] = op_axis;
      }
      Py_DECREF(op_axes_tuple)_Py_DECREF(((PyObject*)(op_axes_tuple)));
      /*
       * Fill the op_nbroadcast=op_ndim-op_ncore axes not yet set,
       * using have_seen_axis to skip over entries set above.
       */
      for (axis = 0, op_axis = 0; axis < op_nbroadcast; axis++) {
          while (have_seen_axis[op_axis]) {
              op_axis++;
          }
          remap_axis[iop][axis] = op_axis++;
      }
      /*
       * Check whether we are actually remapping anything. Here,
       * op_axis can only equal axis if all broadcast axes were the same
       * (i.e., the while loop above was never entered).
       */
      if (axis == op_axis) {
          while (axis < op_ndim && remap_axis[iop][axis] == axis) {
              axis++;
          }
      }
      if (axis == op_ndim) {
          remap_axis[iop] = NULL((void*)0);
      }
  } /* end of for(iop) loop over operands */
  return 0;
1878}

1880/*
* Simplified version of the above, using axis to fill the remap_axis
* array, which maps default to actual axes for each operand, indexed as
* as remap_axis[iop][iaxis]. The default axis order has first all broadcast
* axes and then the core axes the gufunc operates on.
*
* Returns 0 on success, and -1 on failure
*/
1888static int
1889_parse_axis_arg(PyUFuncObject *ufunc, const int core_num_dims[], PyObject *axis,
              PyArrayObject **op, int broadcast_ndim, int **remap_axis) {
  int nop = ufunc->nargs;
  int iop, axis_int;

  axis_int = PyArray_PyIntAsInt(axis);
  if (error_converting(axis_int)(((axis_int) == -1) && PyErr_Occurred())) {
      return -1;
  }

  for (iop = 0; iop < nop; ++iop) {
      int axis, op_ndim, op_axis;

      /* _check_axis_support ensures core_num_dims is 0 or 1 */
      if (core_num_dims[iop] == 0) {
          remap_axis[iop] = NULL((void*)0);
          continue;
      }
      if (op[iop]) {
          op_ndim = PyArray_NDIM(op[iop]);
      }
      else {
          op_ndim = broadcast_ndim + 1;
      }
      op_axis = axis_int;  /* ensure we don't modify axis_int */
      if (check_and_adjust_axis(&op_axis, op_ndim) < 0) {
          return -1;
      }
      /* Are we actually remapping away from last axis? */
      if (op_axis == op_ndim - 1) {
          remap_axis[iop] = NULL((void*)0);
          continue;
      }
      remap_axis[iop][op_ndim - 1] = op_axis;
      for (axis = 0; axis < op_axis; axis++) {
          remap_axis[iop][axis] = axis;
      }
      for (axis = op_axis; axis < op_ndim - 1; axis++) {
          remap_axis[iop][axis] = axis + 1;
      }
  } /* end of for(iop) loop over operands */
  return 0;
1931}

1933#define REMAP_AXIS(iop, axis)((remap_axis != ((void*)0) && remap_axis[iop] != ((void
*)0))? remap_axis[iop][axis] : axis) ((remap_axis != NULL((void*)0) && \
                              remap_axis[iop] != NULL((void*)0))? \
                             remap_axis[iop][axis] : axis)

1937/*
* Validate the core dimensions of all the operands, and collect all of
* the labelled core dimensions into 'core_dim_sizes'.
*
* Returns 0 on success, and -1 on failure
*
* The behavior has been changed in NumPy 1.16.0, and the following
* requirements must be fulfilled or an error will be raised:
*  * Arguments, both input and output, must have at least as many
*    dimensions as the corresponding number of core dimensions. In
*    versions before 1.10, 1's were prepended to the shape as needed.
*  * Core dimensions with same labels must have exactly matching sizes.
*    In versions before 1.10, core dimensions of size 1 would broadcast
*    against other core dimensions with the same label.
*  * All core dimensions must have their size specified by a passed in
*    input or output argument. In versions before 1.10, core dimensions in
*    an output argument that were not specified in an input argument,
*    and whose size could not be inferred from a passed in output
*    argument, would have their size set to 1.
*  * Core dimensions may be fixed, new in NumPy 1.16
*/
1958static int
1959_get_coredim_sizes(PyUFuncObject *ufunc, PyArrayObject **op,
                 const int *op_core_num_dims, npy_uint32 *core_dim_flags,
                 npy_intp *core_dim_sizes, int **remap_axis) {
  int i;
  int nin = ufunc->nin;
  int nout = ufunc->nout;
  int nop = nin + nout;

  for (i = 0; i < nop; ++i) {
      if (op[i] != NULL((void*)0)) {
          int idim;
          int dim_offset = ufunc->core_offsets[i];
          int core_start_dim = PyArray_NDIM(op[i]) - op_core_num_dims[i];
          int dim_delta = 0;

          /* checked before this routine gets called */
          assert(core_start_dim >= 0)((void) (0));

          /*
           * Make sure every core dimension exactly matches all other core
           * dimensions with the same label. Note that flexible dimensions
           * may have been removed at this point, if so, they are marked
           * with UFUNC_CORE_DIM_MISSING.
           */
          for (idim = 0; idim < ufunc->core_num_dims[i]; ++idim) {
              int core_index = dim_offset + idim;
              int core_dim_index = ufunc->core_dim_ixs[core_index];
              npy_intp core_dim_size = core_dim_sizes[core_dim_index];
              npy_intp op_dim_size;

              /* can only happen if flexible; dimension missing altogether */
              if (core_dim_flags[core_dim_index] & UFUNC_CORE_DIM_MISSING0x00040000) {
                  op_dim_size = 1;
                  dim_delta++; /* for indexing in dimensions */
              }
              else {
                  op_dim_size = PyArray_DIM(op[i],
                           REMAP_AXIS(i, core_start_dim + idim - dim_delta)((remap_axis != ((void*)0) && remap_axis[i] != ((void
*)0))? remap_axis[i][core_start_dim + idim - dim_delta] : core_start_dim
 + idim - dim_delta));
              }
              if (core_dim_sizes[core_dim_index] < 0) {
                  core_dim_sizes[core_dim_index] = op_dim_size;
              }
              else if (op_dim_size != core_dim_size) {
                  PyErr_Format(PyExc_ValueError,
                          "%s: %s operand %d has a mismatch in its "
                          "core dimension %d, with gufunc "
                          "signature %s (size %zd is different "
                          "from %zd)",
                          ufunc_get_name_cstr(ufunc), i < nin ? "Input" : "Output",
                          i < nin ? i : i - nin, idim - dim_delta,
                          ufunc->core_signature, op_dim_size,
                          core_dim_sizes[core_dim_index]);
                  return -1;
              }
          }
      }
  }

  /*
   * Make sure no core dimension is unspecified.
   */
  for (i = nin; i < nop; ++i) {
      int idim;
      int dim_offset = ufunc->core_offsets[i];

      for (idim = 0; idim < ufunc->core_num_dims[i]; ++idim) {
          int core_dim_index = ufunc->core_dim_ixs[dim_offset + idim];

          /* check all cases where the size has not yet been set */
          if (core_dim_sizes[core_dim_index] < 0) {
              /*
               * Oops, this dimension was never specified
               * (can only happen if output op not given)
               */
              PyErr_Format(PyExc_ValueError,
                      "%s: Output operand %d has core dimension %d "
                      "unspecified, with gufunc signature %s",
                      ufunc_get_name_cstr(ufunc), i - nin, idim,
                      ufunc->core_signature);
              return -1;
          }
      }
  }

  return 0;
2044}

2046/*
* Returns a new reference
* TODO: store a reference in the ufunc object itself, rather than
*       constructing one each time
*/
2051static PyObject *
2052_get_identity(PyUFuncObject *ufunc, npy_bool *reorderable) {
  switch(ufunc->identity) {
  case PyUFunc_One1:
      *reorderable = 1;
      return PyLong_FromLong(1);

  case PyUFunc_Zero0:
      *reorderable = 1;
      return PyLong_FromLong(0);

  case PyUFunc_MinusOne2:
      *reorderable = 1;
      return PyLong_FromLong(-1);

  case PyUFunc_ReorderableNone-2:
      *reorderable = 1;
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);

  case PyUFunc_None-1:
      *reorderable = 0;
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);

  case PyUFunc_IdentityValue-3:
      *reorderable = 1;
      Py_INCREF(ufunc->identity_value)_Py_INCREF(((PyObject*)(ufunc->identity_value)));
      return ufunc->identity_value;

  default:
      PyErr_Format(PyExc_ValueError,
              "ufunc %s has an invalid identity", ufunc_get_name_cstr(ufunc));
      return NULL((void*)0);
  }
2084}

2086/*
* Copy over parts of the ufunc structure that may need to be
* changed during execution.  Returns 0 on success; -1 otherwise.
*/
2090static int
2091_initialize_variable_parts(PyUFuncObject *ufunc,
                         int op_core_num_dims[],
                         npy_intp core_dim_sizes[],
                         npy_uint32 core_dim_flags[]) {
  int i;

  for (i = 0; i < ufunc->nargs; i++) {
      op_core_num_dims[i] = ufunc->core_num_dims[i];
  }
  for (i = 0; i < ufunc->core_num_dim_ix; i++) {
      core_dim_sizes[i] = ufunc->core_dim_sizes[i];
      core_dim_flags[i] = ufunc->core_dim_flags[i];
  }
  return 0;
2105}

2107static int
2108PyUFunc_GeneralizedFunctionInternal(PyUFuncObject *ufunc, PyArrayObject **op,
      ufunc_full_args full_args, PyObject *type_tup, PyObject *extobj,
      NPY_CASTING casting, NPY_ORDER order, npy_bool subok,
      PyObject *axis, PyObject *axes, int keepdims)
2112{
  int nin, nout;
  int i, j, idim, nop;
  const char *ufunc_name;
  int retval;
  int needs_api = 0;

  PyArray_Descr *dtypes[NPY_MAXARGS32];

  /* Use remapped axes for generalized ufunc */
  int broadcast_ndim, iter_ndim;
  int op_core_num_dims[NPY_MAXARGS32];
  int op_axes_arrays[NPY_MAXARGS32][NPY_MAXDIMS32];
  int *op_axes[NPY_MAXARGS32];
  npy_uint32 core_dim_flags[NPY_MAXARGS32];

  npy_uint32 op_flags[NPY_MAXARGS32];
  npy_intp iter_shape[NPY_MAXARGS32];
  NpyIter *iter = NULL((void*)0);
  npy_uint32 iter_flags;
  npy_intp total_problem_size;

  /* These parameters come from extobj= or from a TLS global */
  int buffersize = 0, errormask = 0;

  /* The selected inner loop */
  PyUFuncGenericFunction innerloop = NULL((void*)0);
  void *innerloopdata = NULL((void*)0);
  /* The dimensions which get passed to the inner loop */
  npy_intp inner_dimensions[NPY_MAXDIMS32+1];
  /* The strides which get passed to the inner loop */
  npy_intp *inner_strides = NULL((void*)0);

  /* The sizes of the core dimensions (# entries is ufunc->core_num_dim_ix) */
  npy_intp *core_dim_sizes = inner_dimensions + 1;
  int core_dim_ixs_size;
  /* swapping around of axes */
  int *remap_axis_memory = NULL((void*)0);
  int **remap_axis = NULL((void*)0);
  /* The __array_prepare__ function to call for each output */
  PyObject *arr_prep[NPY_MAXARGS32];

  nin = ufunc->nin;
  nout = ufunc->nout;
  nop = nin + nout;

  ufunc_name = ufunc_get_name_cstr(ufunc);

  NPY_UF_DBG_PRINT1("\nEvaluating ufunc %s\n", ufunc_name);

  /* Initialize all dtypes and __array_prepare__ call-backs to NULL */
  for (i = 0; i < nop; ++i) {
      dtypes[i] = NULL((void*)0);
      arr_prep[i] = NULL((void*)0);
  }
  /* Initialize possibly variable parts to the values from the ufunc */
  retval = _initialize_variable_parts(ufunc, op_core_num_dims,
                                      core_dim_sizes, core_dim_flags);
  if (retval < 0) {
      goto fail;
  }

  /*
   * If keepdims was passed in (and thus changed from the initial value
   * on top), check the gufunc is suitable, i.e., that its inputs share
   * the same number of core dimensions, and its outputs have none.
   */
  if (keepdims != -1) {
      retval = _check_keepdims_support(ufunc);
      if (retval < 0) {
          goto fail;
      }
  }
  if (axis != NULL((void*)0)) {
      retval = _check_axis_support(ufunc);
      if (retval < 0) {
          goto fail;
      }
  }
  /*
   * If keepdims is set and true, which means all input dimensions are
   * the same, signal that all output dimensions will be the same too.
   */
  if (keepdims == 1) {
      int num_dims = op_core_num_dims[0];
      for (i = nin; i < nop; ++i) {
          op_core_num_dims[i] = num_dims;
      }
  }
  else {
      /* keepdims was not set or was false; no adjustment necessary */
      keepdims = 0;
  }
  /*
   * Check that operands have the minimum dimensions required.
   * (Just checks core; broadcast dimensions are tested by the iterator.)
   */
  retval = _validate_num_dims(ufunc, op, core_dim_flags,
                              op_core_num_dims);
  if (retval < 0) {
      goto fail;
  }
  /*
   * Figure out the number of iteration dimensions, which
   * is the broadcast result of all the non-core dimensions.
   * (We do allow outputs to broadcast inputs currently, if they are given.
   * This is in line with what normal ufuncs do.)
   */
  broadcast_ndim = 0;
  for (i = 0; i < nop; ++i) {
      if (op[i] == NULL((void*)0)) {
          continue;
      }
      int n = PyArray_NDIM(op[i]) - op_core_num_dims[i];
      if (n > broadcast_ndim) {
          broadcast_ndim = n;
      }
  }

  /* Possibly remap axes. */
  if (axes != NULL((void*)0) || axis != NULL((void*)0)) {
      assert(!(axes != NULL && axis != NULL))((void) (0));

      remap_axis = PyArray_mallocPyMem_RawMalloc(sizeof(remap_axis[0]) * nop);
      remap_axis_memory = PyArray_mallocPyMem_RawMalloc(sizeof(remap_axis_memory[0]) *
                                                nop * NPY_MAXDIMS32);
      if (remap_axis == NULL((void*)0) || remap_axis_memory == NULL((void*)0)) {
          PyErr_NoMemory();
          goto fail;
      }
      for (i=0; i < nop; i++) {
          remap_axis[i] = remap_axis_memory + i * NPY_MAXDIMS32;
      }
      if (axis) {
          retval = _parse_axis_arg(ufunc, op_core_num_dims, axis, op,
                                   broadcast_ndim, remap_axis);
      }
      else {
          retval = _parse_axes_arg(ufunc, op_core_num_dims, axes, op,
                                   broadcast_ndim, remap_axis);
      }
      if(retval < 0) {
          goto fail;
      }
  }

  /* Collect the lengths of the labelled core dimensions */
  retval = _get_coredim_sizes(ufunc, op, op_core_num_dims, core_dim_flags,
                              core_dim_sizes, remap_axis);
  if(retval < 0) {
      goto fail;
  }
  /*
   * Figure out the number of iterator creation dimensions,
   * which is the broadcast dimensions + all the core dimensions of
   * the outputs, so that the iterator can allocate those output
   * dimensions following the rules of order='F', for example.
   */
  iter_ndim = broadcast_ndim;
  for (i = nin; i < nop; ++i) {
      iter_ndim += op_core_num_dims[i];
  }
  if (iter_ndim > NPY_MAXDIMS32) {
      PyErr_Format(PyExc_ValueError,
                  "too many dimensions for generalized ufunc %s",
                  ufunc_name);
      retval = -1;
      goto fail;
  }

  /* Fill in the initial part of 'iter_shape' */
  for (idim = 0; idim < broadcast_ndim; ++idim) {
      iter_shape[idim] = -1;
  }

  /* Fill in op_axes for all the operands */
  j = broadcast_ndim;
  for (i = 0; i < nop; ++i) {
      int n;

      if (op[i]) {
          n = PyArray_NDIM(op[i]) - op_core_num_dims[i];
      }
      else {
          n = broadcast_ndim;
      }
      /* Broadcast all the unspecified dimensions normally */
      for (idim = 0; idim < broadcast_ndim; ++idim) {
          if (idim >= broadcast_ndim - n) {
              op_axes_arrays[i][idim] =
                  REMAP_AXIS(i, idim - (broadcast_ndim - n))((remap_axis != ((void*)0) && remap_axis[i] != ((void
*)0))? remap_axis[i][idim - (broadcast_ndim - n)] : idim - (broadcast_ndim
 - n));
          }
          else {
              op_axes_arrays[i][idim] = -1;
          }
      }

      /*
       * Any output core dimensions shape should be ignored, so we add
       * it as a Reduce dimension (which can be broadcast with the rest).
       * These will be removed before the actual iteration for gufuncs.
       */
      for (idim = broadcast_ndim; idim < iter_ndim; ++idim) {
          op_axes_arrays[i][idim] = NPY_ITER_REDUCTION_AXIS(-1)(-1 + (1 << ((4 * 8) - 2)));
      }

      /* Except for when it belongs to this output */
      if (i >= nin) {
          int dim_offset = ufunc->core_offsets[i];
          int num_removed = 0;
          /*
           * Fill in 'iter_shape' and 'op_axes' for the core dimensions
           * of this output. Here, we have to be careful: if keepdims
           * was used, then the axes are not real core dimensions, but
           * are being added back for broadcasting, so their size is 1.
           * If the axis was removed, we should skip altogether.
           */
          if (keepdims) {
              for (idim = 0; idim < op_core_num_dims[i]; ++idim) {
                  iter_shape[j] = 1;
                  op_axes_arrays[i][j] = REMAP_AXIS(i, n + idim)((remap_axis != ((void*)0) && remap_axis[i] != ((void
*)0))? remap_axis[i][n + idim] : n + idim);
                  ++j;
              }
          }
          else {
              for (idim = 0; idim < ufunc->core_num_dims[i]; ++idim) {
                  int core_index = dim_offset + idim;
                  int core_dim_index = ufunc->core_dim_ixs[core_index];
                  if ((core_dim_flags[core_dim_index] &
                       UFUNC_CORE_DIM_MISSING0x00040000)) {
                      /* skip it */
                      num_removed++;
                      continue;
                  }
                  iter_shape[j] = core_dim_sizes[ufunc->core_dim_ixs[core_index]];
                  op_axes_arrays[i][j] = REMAP_AXIS(i, n + idim - num_removed)((remap_axis != ((void*)0) && remap_axis[i] != ((void
*)0))? remap_axis[i][n + idim - num_removed] : n + idim - num_removed
);
                  ++j;
              }
          }
      }

      op_axes[i] = op_axes_arrays[i];
  }

2356#if NPY_UF_DBG_TRACING0
  printf("iter shapes:")__printf_chk (2 - 1, "iter shapes:");
  for (j=0; j < iter_ndim; j++) {
      printf(" %ld", iter_shape[j])__printf_chk (2 - 1, " %ld", iter_shape[j]);
  }
  printf("\n")__printf_chk (2 - 1, "\n");
2362#endif

  /* Get the buffersize and errormask */
  if (_get_bufsize_errmask(extobj, ufunc_name, &buffersize, &errormask) < 0) {
      retval = -1;
      goto fail;
  }

  NPY_UF_DBG_PRINT("Finding inner loop\n");


  retval = ufunc->type_resolver(ufunc, casting,
                          op, type_tup, dtypes);
  if (retval < 0) {
      goto fail;
  }
  /*
   * We don't write to all elements, and the iterator may make
   * UPDATEIFCOPY temporary copies. The output arrays (unless they are
   * allocated by the iterator itself) must be considered READWRITE by the
   * iterator, so that the elements we don't write to are copied to the
   * possible temporary array.
   */
  _ufunc_setup_flags(ufunc, NPY_ITER_COPY0x00400000 | NPY_UFUNC_DEFAULT_INPUT_FLAGS0x00020000 | 0x00100000 | 0x40000000,
                     NPY_ITER_UPDATEIFCOPY0x00800000 |
                     NPY_ITER_WRITEONLY0x00040000 |
                     NPY_UFUNC_DEFAULT_OUTPUT_FLAGS0x00100000 | 0x01000000 | 0x08000000 | 0x02000000 | 0x40000000,
                     op_flags);
  /* For the generalized ufunc, we get the loop right away too */
  retval = ufunc->legacy_inner_loop_selector(ufunc, dtypes,
                                  &innerloop, &innerloopdata, &needs_api);
  if (retval < 0) {
      goto fail;
  }

2397#if NPY_UF_DBG_TRACING0
  printf("input types:\n")__printf_chk (2 - 1, "input types:\n");
  for (i = 0; i < nin; ++i) {
      PyObject_Print((PyObject *)dtypes[i], stdoutstdout, 0);
      printf(" ")__printf_chk (2 - 1, " ");
  }
  printf("\noutput types:\n")__printf_chk (2 - 1, "\noutput types:\n");
  for (i = nin; i < nop; ++i) {
      PyObject_Print((PyObject *)dtypes[i], stdoutstdout, 0);
      printf(" ")__printf_chk (2 - 1, " ");
  }
  printf("\n")__printf_chk (2 - 1, "\n");
2409#endif

  if (subok) {
      /*
       * Get the appropriate __array_prepare__ function to call
       * for each output
       */
      _find_array_prepare(full_args, arr_prep, nout);
  }

  /*
   * Set up the iterator per-op flags.  For generalized ufuncs, we
   * can't do buffering, so must COPY or UPDATEIFCOPY.
   */

  iter_flags = ufunc->iter_flags |
               NPY_ITER_MULTI_INDEX0x00000004 |
               NPY_ITER_REFS_OK0x00000020 |
               NPY_ITER_ZEROSIZE_OK0x00000040 |
               NPY_ITER_COPY_IF_OVERLAP0x00002000;

  /* Create the iterator */
  iter = NpyIter_AdvancedNew(nop, op, iter_flags,
                         order, NPY_UNSAFE_CASTING, op_flags,
                         dtypes, iter_ndim,
                         op_axes, iter_shape, 0);
  if (iter == NULL((void*)0)) {
      retval = -1;
      goto fail;
  }

  /* Fill in any allocated outputs */
  {
      PyArrayObject **operands = NpyIter_GetOperandArray(iter);
      for (i = nin; i < nop; ++i) {
          if (op[i] == NULL((void*)0)) {
              op[i] = operands[i];
              Py_INCREF(op[i])_Py_INCREF(((PyObject*)(op[i])));
          }
      }
  }
  /*
   * Set up the inner strides array. Because we're not doing
   * buffering, the strides are fixed throughout the looping.
   */
  core_dim_ixs_size = 0;
  for (i = 0; i < nop; ++i) {
      core_dim_ixs_size += ufunc->core_num_dims[i];
  }
  inner_strides = (npy_intp *)PyArray_mallocPyMem_RawMalloc(
                      NPY_SIZEOF_INTP8 * (nop+core_dim_ixs_size));
  if (inner_strides == NULL((void*)0)) {
      PyErr_NoMemory();
      retval = -1;
      goto fail;
  }
  /* Copy the strides after the first nop */
  idim = nop;
  for (i = 0; i < nop; ++i) {
      /*
       * Need to use the arrays in the iterator, not op, because
       * a copy with a different-sized type may have been made.
       */
      PyArrayObject *arr = NpyIter_GetOperandArray(iter)[i];
      npy_intp *shape = PyArray_SHAPE(arr);
      npy_intp *strides = PyArray_STRIDES(arr);
      /*
       * Could be negative if flexible dims are used, but not for
       * keepdims, since those dimensions are allocated in arr.
       */
      int core_start_dim = PyArray_NDIM(arr) - op_core_num_dims[i];
      int num_removed = 0;
      int dim_offset = ufunc->core_offsets[i];

      for (j = 0; j < ufunc->core_num_dims[i]; ++j) {
          int core_dim_index = ufunc->core_dim_ixs[dim_offset + j];
          /*
           * Force zero stride when the shape is 1 (always the case for
           * for missing dimensions), so that broadcasting works right.
           */
          if (core_dim_flags[core_dim_index] & UFUNC_CORE_DIM_MISSING0x00040000) {
              num_removed++;
              inner_strides[idim++] = 0;
          }
          else {
              int remapped_axis = REMAP_AXIS(i, core_start_dim + j - num_removed)((remap_axis != ((void*)0) && remap_axis[i] != ((void
*)0))? remap_axis[i][core_start_dim + j - num_removed] : core_start_dim
 + j - num_removed);
              if (shape[remapped_axis] != 1) {
                  inner_strides[idim++] = strides[remapped_axis];
              } else {
                  inner_strides[idim++] = 0;
              }
          }
      }
  }

  total_problem_size = NpyIter_GetIterSize(iter);
  if (total_problem_size < 0) {
      /*
       * Only used for threading, if negative (this means that it is
       * larger then ssize_t before axes removal) assume that the actual
       * problem is large enough to be threaded usefully.
       */
      total_problem_size = 1000;
  }

  /* Remove all the core output dimensions from the iterator */
  for (i = broadcast_ndim; i < iter_ndim; ++i) {
      if (NpyIter_RemoveAxis(iter, broadcast_ndim) != NPY_SUCCEED1) {
          retval = -1;
          goto fail;
      }
  }
  if (NpyIter_RemoveMultiIndex(iter) != NPY_SUCCEED1) {
      retval = -1;
      goto fail;
  }
  if (NpyIter_EnableExternalLoop(iter) != NPY_SUCCEED1) {
      retval = -1;
      goto fail;
  }

  /*
   * The first nop strides are for the inner loop (but only can
   * copy them after removing the core axes)
   */
  memcpy(inner_strides, NpyIter_GetInnerStrideArray(iter),
                                  NPY_SIZEOF_INTP8 * nop);

2537#if 0
  printf("strides: ")__printf_chk (2 - 1, "strides: ");
  for (i = 0; i < nop+core_dim_ixs_size; ++i) {
      printf("%d ", (int)inner_strides[i])__printf_chk (2 - 1, "%d ", (int)inner_strides[i]);
  }
  printf("\n")__printf_chk (2 - 1, "\n");
2543#endif

  /* Start with the floating-point exception flags cleared */
  npy_clear_floatstatus_barrier((char*)&iter);

  NPY_UF_DBG_PRINT("Executing inner loop\n");

  if (NpyIter_GetIterSize(iter) != 0) {
      /* Do the ufunc loop */
      NpyIter_IterNextFunc *iternext;
      char **dataptr;
      npy_intp *count_ptr;
      NPY_BEGIN_THREADS_DEFPyThreadState *_save=((void*)0);;

      /* Get the variables needed for the loop */
      iternext = NpyIter_GetIterNext(iter, NULL((void*)0));
      if (iternext == NULL((void*)0)) {
          retval = -1;
          goto fail;
      }
      dataptr = NpyIter_GetDataPtrArray(iter);
      count_ptr = NpyIter_GetInnerLoopSizePtr(iter);
      needs_api = NpyIter_IterationNeedsAPI(iter);

      if (!needs_api && !NpyIter_IterationNeedsAPI(iter)) {
          NPY_BEGIN_THREADS_THRESHOLDED(total_problem_size)do { if ((total_problem_size) > 500) { _save = PyEval_SaveThread
();} } while (0);;
      }
      do {
          inner_dimensions[0] = *count_ptr;
          innerloop(dataptr, inner_dimensions, inner_strides, innerloopdata);
      } while (!(needs_api && PyErr_Occurred()) && iternext(iter));

      if (!needs_api && !NpyIter_IterationNeedsAPI(iter)) {
          NPY_END_THREADSdo { if (_save) { PyEval_RestoreThread(_save); _save = ((void
*)0);} } while (0);;
      }
  }

  /* Check whether any errors occurred during the loop */
  if (PyErr_Occurred() ||
      _check_ufunc_fperr(errormask, extobj, ufunc_name) < 0) {
      retval = -1;
      goto fail;
  }

  PyArray_freePyMem_RawFree(inner_strides);
  if (NpyIter_Deallocate(iter) < 0) {
      retval = -1;
  }

  /* The caller takes ownership of all the references in op */
  for (i = 0; i < nop; ++i) {
      Py_XDECREF(dtypes[i])_Py_XDECREF(((PyObject*)(dtypes[i])));
      Py_XDECREF(arr_prep[i])_Py_XDECREF(((PyObject*)(arr_prep[i])));
  }
  PyArray_freePyMem_RawFree(remap_axis_memory);
  PyArray_freePyMem_RawFree(remap_axis);

  NPY_UF_DBG_PRINT1("Returning code %d\n", retval);

  return retval;

2604fail:
  NPY_UF_DBG_PRINT1("Returning failure code %d\n", retval);
  PyArray_freePyMem_RawFree(inner_strides);
  NpyIter_Deallocate(iter);
  for (i = 0; i < nop; ++i) {
      Py_XDECREF(dtypes[i])_Py_XDECREF(((PyObject*)(dtypes[i])));
      Py_XDECREF(arr_prep[i])_Py_XDECREF(((PyObject*)(arr_prep[i])));
  }
  PyArray_freePyMem_RawFree(remap_axis_memory);
  PyArray_freePyMem_RawFree(remap_axis);
  return retval;
2615}


2618static int
2619PyUFunc_GenericFunctionInternal(PyUFuncObject *ufunc, PyArrayObject **op,
      ufunc_full_args full_args, PyObject *type_tup, PyObject *extobj,
      NPY_CASTING casting, NPY_ORDER order, npy_bool subok,
      PyArrayObject *wheremask)
2623{
  int nin, nout;
  int i, nop;
  const char *ufunc_name;
  int retval = -1;
  npy_uint32 op_flags[NPY_MAXARGS32];
  npy_intp default_op_out_flags;

  PyArray_Descr *dtypes[NPY_MAXARGS32];

  /* These parameters come from extobj= or from a TLS global */
  int buffersize = 0, errormask = 0;

  /* The __array_prepare__ function to call for each output */
  PyObject *arr_prep[NPY_MAXARGS32];

  int trivial_loop_ok = 0;

  nin = ufunc->nin;
  nout = ufunc->nout;
  nop = nin + nout;

  ufunc_name = ufunc_get_name_cstr(ufunc);

  NPY_UF_DBG_PRINT1("\nEvaluating ufunc %s\n", ufunc_name);

  /* Initialize all the dtypes and __array_prepare__ callbacks to NULL */
  for (i = 0; i < nop; ++i) {
      dtypes[i] = NULL((void*)0);
      arr_prep[i] = NULL((void*)0);
  }

  /* Get the buffersize and errormask */
  if (_get_bufsize_errmask(extobj, ufunc_name, &buffersize, &errormask) < 0) {
      retval = -1;
      goto fail;
  }

  NPY_UF_DBG_PRINT("Finding inner loop\n");

  retval = ufunc->type_resolver(ufunc, casting,
                          op, type_tup, dtypes);
  if (retval < 0) {
      goto fail;
  }

  if (wheremask != NULL((void*)0)) {
      /* Set up the flags. */
      default_op_out_flags = NPY_ITER_NO_SUBTYPE0x02000000 |
                             NPY_ITER_WRITEMASKED0x10000000 |
                             NPY_UFUNC_DEFAULT_OUTPUT_FLAGS0x00100000 | 0x01000000 | 0x08000000 | 0x02000000 | 0x40000000;
      _ufunc_setup_flags(ufunc, NPY_UFUNC_DEFAULT_INPUT_FLAGS0x00020000 | 0x00100000 | 0x40000000,
                         default_op_out_flags, op_flags);
  }
  else {
      /* Set up the flags. */
      default_op_out_flags = NPY_ITER_WRITEONLY0x00040000 |
                             NPY_UFUNC_DEFAULT_OUTPUT_FLAGS0x00100000 | 0x01000000 | 0x08000000 | 0x02000000 | 0x40000000;
      _ufunc_setup_flags(ufunc, NPY_UFUNC_DEFAULT_INPUT_FLAGS0x00020000 | 0x00100000 | 0x40000000,
                         default_op_out_flags, op_flags);
  }

2685#if NPY_UF_DBG_TRACING0
  printf("input types:\n")__printf_chk (2 - 1, "input types:\n");
  for (i = 0; i < nin; ++i) {
      PyObject_Print((PyObject *)dtypes[i], stdoutstdout, 0);
      printf(" ")__printf_chk (2 - 1, " ");
  }
  printf("\noutput types:\n")__printf_chk (2 - 1, "\noutput types:\n");
  for (i = nin; i < nop; ++i) {
      PyObject_Print((PyObject *)dtypes[i], stdoutstdout, 0);
      printf(" ")__printf_chk (2 - 1, " ");
  }
  printf("\n")__printf_chk (2 - 1, "\n");
2697#endif

  if (subok) {
      /*
       * Get the appropriate __array_prepare__ function to call
       * for each output
       */
      _find_array_prepare(full_args, arr_prep, nout);
  }

  /* Do the ufunc loop */
  if (wheremask != NULL((void*)0)) {
      NPY_UF_DBG_PRINT("Executing fancy inner loop\n");

      if (nop + 1 > NPY_MAXARGS32) {
          PyErr_SetString(PyExc_ValueError,
                  "Too many operands when including where= parameter");
          return -1;
      }
      op[nop] = wheremask;
      dtypes[nop] = NULL((void*)0);

      /* Set up the flags */

      npy_clear_floatstatus_barrier((char*)&ufunc);
      retval = execute_fancy_ufunc_loop(ufunc, wheremask,
                          op, dtypes, order,
                          buffersize, arr_prep, full_args, op_flags);
  }
  else {
      NPY_UF_DBG_PRINT("Executing legacy inner loop\n");

      /*
       * This checks whether a trivial loop is ok, making copies of
       * scalar and one dimensional operands if that will help.
       * Since it requires dtypes, it can only be called after
       * ufunc->type_resolver
       */
      trivial_loop_ok = check_for_trivial_loop(ufunc, op, dtypes, buffersize);
      if (trivial_loop_ok < 0) {
          goto fail;
      }

      /* check_for_trivial_loop on half-floats can overflow */
      npy_clear_floatstatus_barrier((char*)&ufunc);

      retval = execute_legacy_ufunc_loop(ufunc, trivial_loop_ok,
                          op, dtypes, order,
                          buffersize, arr_prep, full_args, op_flags);
  }
  if (retval < 0) {
      goto fail;
  }

  /*
   * Check whether any errors occurred during the loop. The loops should
   * indicate this in retval, but since the inner-loop currently does not
   * report errors, this does not happen in all branches (at this time).
   */
  if (PyErr_Occurred() ||
          _check_ufunc_fperr(errormask, extobj, ufunc_name) < 0) {
      retval = -1;
      goto fail;
  }


  /* The caller takes ownership of all the references in op */
  for (i = 0; i < nop; ++i) {
      Py_XDECREF(dtypes[i])_Py_XDECREF(((PyObject*)(dtypes[i])));
      Py_XDECREF(arr_prep[i])_Py_XDECREF(((PyObject*)(arr_prep[i])));
  }

  NPY_UF_DBG_PRINT("Returning success code 0\n");

  return 0;

2773fail:
  NPY_UF_DBG_PRINT1("Returning failure code %d\n", retval);
  for (i = 0; i < nop; ++i) {
      Py_XDECREF(dtypes[i])_Py_XDECREF(((PyObject*)(dtypes[i])));
      Py_XDECREF(arr_prep[i])_Py_XDECREF(((PyObject*)(arr_prep[i])));
  }

  return retval;
2781}


2784/*UFUNC_API*/
2785NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
2786PyUFunc_GenericFunction(PyUFuncObject *NPY_UNUSED(ufunc)(__NPY_UNUSED_TAGGEDufunc) __attribute__ ((__unused__)),
      PyObject *NPY_UNUSED(args)(__NPY_UNUSED_TAGGEDargs) __attribute__ ((__unused__)), PyObject *NPY_UNUSED(kwds)(__NPY_UNUSED_TAGGEDkwds) __attribute__ ((__unused__)),
      PyArrayObject **NPY_UNUSED(op)(__NPY_UNUSED_TAGGEDop) __attribute__ ((__unused__)))
2789{
  /* NumPy 1.21, 2020-03-29 */
  PyErr_SetString(PyExc_RuntimeError,
          "The `PyUFunc_GenericFunction()` C-API function has been disabled. "
          "Please use `PyObject_Call(ufunc, args, kwargs)`, which has "
          "identical behaviour but allows subclass and `__array_ufunc__` "
          "override handling and only returns the normal ufunc result.");
  return -1;
2797}


2800/*
* Given the output type, finds the specified binary op.  The
* ufunc must have nin==2 and nout==1.  The function may modify
* otype if the given type isn't found.
*
* Returns 0 on success, -1 on failure.
*/
2807static int
2808get_binary_op_function(PyUFuncObject *ufunc, int *otype,
                      PyUFuncGenericFunction *out_innerloop,
                      void **out_innerloopdata)
2811{
  int i;

  NPY_UF_DBG_PRINT1("Getting binary op function for type number %d\n",
                              *otype);

  /* If the type is custom and there are userloops, search for it here */
  if (ufunc->userloops != NULL((void*)0) && PyTypeNum_ISUSERDEF(*otype)(((*otype) >= NPY_USERDEF) && ((*otype) < NPY_USERDEF
+ NPY_NUMUSERTYPES))) {
      PyObject *key, *obj;
      key = PyLong_FromLong(*otype);
      if (key == NULL((void*)0)) {
          return -1;
      }
      obj = PyDict_GetItemWithError(ufunc->userloops, key);
      Py_DECREF(key)_Py_DECREF(((PyObject*)(key)));
      if (obj == NULL((void*)0) && PyErr_Occurred()) {
          return -1;
      }
      else if (obj != NULL((void*)0)) {
          PyUFunc_Loop1d *funcdata = PyCapsule_GetPointer(obj, NULL((void*)0));
          if (funcdata == NULL((void*)0)) {
              return -1;
          }
          while (funcdata != NULL((void*)0)) {
              int *types = funcdata->arg_types;

              if (types[0] == *otype && types[1] == *otype &&
                                              types[2] == *otype) {
                  *out_innerloop = funcdata->func;
                  *out_innerloopdata = funcdata->data;
                  return 0;
              }

              funcdata = funcdata->next;
          }
      }
  }

  /* Search for a function with compatible inputs */
  for (i = 0; i < ufunc->ntypes; ++i) {
      char *types = ufunc->types + i*ufunc->nargs;

      NPY_UF_DBG_PRINT3("Trying loop with signature %d %d -> %d\n",
                              types[0], types[1], types[2]);

      if (PyArray_CanCastSafely(*otype, types[0]) &&
                  types[0] == types[1] &&
                  (*otype == NPY_OBJECT || types[0] != NPY_OBJECT)) {
          /* If the signature is "xx->x", we found the loop */
          if (types[2] == types[0]) {
              *out_innerloop = ufunc->functions[i];
              *out_innerloopdata = ufunc->data[i];
              *otype = types[0];
              return 0;
          }
          /*
           * Otherwise, we found the natural type of the reduction,
           * replace otype and search again
           */
          else {
              *otype = types[2];
              break;
          }
      }
  }

  /* Search for the exact function */
  for (i = 0; i < ufunc->ntypes; ++i) {
      char *types = ufunc->types + i*ufunc->nargs;

      if (PyArray_CanCastSafely(*otype, types[0]) &&
                  types[0] == types[1] &&
                  types[1] == types[2] &&
                  (*otype == NPY_OBJECT || types[0] != NPY_OBJECT)) {
          /* Since the signature is "xx->x", we found the loop */
          *out_innerloop = ufunc->functions[i];
          *out_innerloopdata = ufunc->data[i];
          *otype = types[0];
          return 0;
      }
  }

  return -1;
2894}

2896static int
2897reduce_type_resolver(PyUFuncObject *ufunc, PyArrayObject *arr,
                      PyArray_Descr *odtype, PyArray_Descr **out_dtype)
2899{
  int i, retcode;
  PyArrayObject *op[3] = {arr, arr, NULL((void*)0)};
  PyArray_Descr *dtypes[3] = {NULL((void*)0), NULL((void*)0), NULL((void*)0)};
  const char *ufunc_name = ufunc_get_name_cstr(ufunc);
  PyObject *type_tup = NULL((void*)0);

  *out_dtype = NULL((void*)0);

  /*
   * If odtype is specified, make a type tuple for the type
   * resolution.
   */
  if (odtype != NULL((void*)0)) {
      type_tup = PyTuple_Pack(3, odtype, odtype, Py_None(&_Py_NoneStruct));
      if (type_tup == NULL((void*)0)) {
          return -1;
      }
  }

  /* Use the type resolution function to find our loop */
  retcode = ufunc->type_resolver(
                      ufunc, NPY_UNSAFE_CASTING,
                      op, type_tup, dtypes);
  Py_DECREF(type_tup)_Py_DECREF(((PyObject*)(type_tup)));
  if (retcode == -1) {
      return -1;
  }
  else if (retcode == -2) {
      PyErr_Format(PyExc_RuntimeError,
              "type resolution returned NotImplemented to "
              "reduce ufunc %s", ufunc_name);
      return -1;
  }

  /*
   * The first two type should be equivalent. Because of how
   * reduce has historically behaved in NumPy, the return type
   * could be different, and it is the return type on which the
   * reduction occurs.
   */
  if (!PyArray_EquivTypes(dtypes[0], dtypes[1])) {
      for (i = 0; i < 3; ++i) {
          Py_DECREF(dtypes[i])_Py_DECREF(((PyObject*)(dtypes[i])));
      }
      PyErr_Format(PyExc_RuntimeError,
              "could not find a type resolution appropriate for "
              "reduce ufunc %s", ufunc_name);
      return -1;
  }

  Py_DECREF(dtypes[0])_Py_DECREF(((PyObject*)(dtypes[0])));
  Py_DECREF(dtypes[1])_Py_DECREF(((PyObject*)(dtypes[1])));
  *out_dtype = dtypes[2];

  return 0;
2955}

2957static int
2958reduce_loop(NpyIter *iter, char **dataptrs, npy_intp const *strides,
          npy_intp const *countptr, NpyIter_IterNextFunc *iternext,
          int needs_api, npy_intp skip_first_count, void *data)
2961{
  PyArray_Descr *dtypes[3], **iter_dtypes;
  PyUFuncObject *ufunc = (PyUFuncObject *)data;
  char *dataptrs_copy[3];
  npy_intp strides_copy[3];
  npy_bool masked;

  /* The normal selected inner loop */
  PyUFuncGenericFunction innerloop = NULL((void*)0);
  void *innerloopdata = NULL((void*)0);

  NPY_BEGIN_THREADS_DEFPyThreadState *_save=((void*)0);;
  /* Get the number of operands, to determine whether "where" is used */
  masked = (NpyIter_GetNOp(iter) == 3);

  /* Get the inner loop */
  iter_dtypes = NpyIter_GetDescrArray(iter);
  dtypes[0] = iter_dtypes[0];
  dtypes[1] = iter_dtypes[1];
  dtypes[2] = iter_dtypes[0];
  if (ufunc->legacy_inner_loop_selector(ufunc, dtypes,
                          &innerloop, &innerloopdata, &needs_api) < 0) {
      return -1;
  }

  NPY_BEGIN_THREADS_NDITER(iter)do { if (!NpyIter_IterationNeedsAPI(iter)) { do { if ((NpyIter_GetIterSize
(iter)) > 500) { _save = PyEval_SaveThread();} } while (0)
;; } } while(0);

  if (skip_first_count > 0) {
      do {
          npy_intp count = *countptr;

          /* Skip any first-visit elements */
          if (NpyIter_IsFirstVisit(iter, 0)) {
              if (strides[0] == 0) {
                  --count;
                  --skip_first_count;
                  dataptrs[1] += strides[1];
              }
              else {
                  skip_first_count -= count;
                  count = 0;
              }
          }

          /* Turn the two items into three for the inner loop */
          dataptrs_copy[0] = dataptrs[0];
          dataptrs_copy[1] = dataptrs[1];
          dataptrs_copy[2] = dataptrs[0];
          strides_copy[0] = strides[0];
          strides_copy[1] = strides[1];
          strides_copy[2] = strides[0];
          innerloop(dataptrs_copy, &count,
                      strides_copy, innerloopdata);

          if (needs_api && PyErr_Occurred()) {
              goto finish_loop;
          }

          /* Jump to the faster loop when skipping is done */
          if (skip_first_count == 0) {
              if (iternext(iter)) {
                  break;
              }
              else {
                  goto finish_loop;
              }
          }
      } while (iternext(iter));
  }

  if (needs_api && PyErr_Occurred()) {
      goto finish_loop;
  }

  do {
      /* Turn the two items into three for the inner loop */
      dataptrs_copy[0] = dataptrs[0];
      dataptrs_copy[1] = dataptrs[1];
      dataptrs_copy[2] = dataptrs[0];
      strides_copy[0] = strides[0];
      strides_copy[1] = strides[1];
      strides_copy[2] = strides[0];

      if (!masked) {
          innerloop(dataptrs_copy, countptr,
                    strides_copy, innerloopdata);
      }
      else {
          npy_intp count = *countptr;
          char *maskptr = dataptrs[2];
          npy_intp mask_stride = strides[2];
          /* Optimization for when the mask is broadcast */
          npy_intp n = mask_stride == 0 ? count : 1;
          while (count) {
              char mask = *maskptr;
              maskptr += mask_stride;
              while (n < count && mask == *maskptr) {
                  n++;
                  maskptr += mask_stride;
              }
              /* If mask set, apply inner loop on this contiguous region */
              if (mask) {
                  innerloop(dataptrs_copy, &n,
                            strides_copy, innerloopdata);
              }
              dataptrs_copy[0] += n * strides[0];
              dataptrs_copy[1] += n * strides[1];
              dataptrs_copy[2] = dataptrs_copy[0];
              count -= n;
              n = 1;
          }
      }
  } while (!(needs_api && PyErr_Occurred()) && iternext(iter));

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

  return (needs_api && PyErr_Occurred()) ? -1 : 0;
3079}

3081/*
* The implementation of the reduction operators with the new iterator
* turned into a bit of a long function here, but I think the design
* of this part needs to be changed to be more like einsum, so it may
* not be worth refactoring it too much.  Consider this timing:
*
* >>> a = arange(10000)
*
* >>> timeit sum(a)
* 10000 loops, best of 3: 17 us per loop
*
* >>> timeit einsum("i->",a)
* 100000 loops, best of 3: 13.5 us per loop
*
* The axes must already be bounds-checked by the calling function,
* this function does not validate them.
*/
3098static PyArrayObject *
3099PyUFunc_Reduce(PyUFuncObject *ufunc, PyArrayObject *arr, PyArrayObject *out,
      int naxes, int *axes, PyArray_Descr *odtype, int keepdims,
      PyObject *initial, PyArrayObject *wheremask)
3102{
  int iaxes, ndim;
  npy_bool reorderable;
  npy_bool axis_flags[NPY_MAXDIMS32];
  PyArray_Descr *dtype;
  PyArrayObject *result;
  PyObject *identity;
  const char *ufunc_name = ufunc_get_name_cstr(ufunc);
  /* These parameters come from a TLS global */
  int buffersize = 0, errormask = 0;

  NPY_UF_DBG_PRINT1("\nEvaluating ufunc %s.reduce\n", ufunc_name);

  ndim = PyArray_NDIM(arr);

  /* Create an array of flags for reduction */
  memset(axis_flags, 0, ndim);
  for (iaxes = 0; iaxes < naxes; ++iaxes) {
      int axis = axes[iaxes];
      if (axis_flags[axis]) {
          PyErr_SetString(PyExc_ValueError,
                  "duplicate value in 'axis'");
          return NULL((void*)0);
      }
      axis_flags[axis] = 1;
  }

  if (_get_bufsize_errmask(NULL((void*)0), "reduce", &buffersize, &errormask) < 0) {
      return NULL((void*)0);
  }

  /* Get the identity */
  identity = _get_identity(ufunc, &reorderable);
  if (identity == NULL((void*)0)) {
      return NULL((void*)0);
  }

  /* Get the initial value */
  if (initial == NULL((void*)0)) {
      initial = identity;

      /*
      * The identity for a dynamic dtype like
      * object arrays can't be used in general
      */
      if (initial != Py_None(&_Py_NoneStruct) && PyArray_ISOBJECT(arr)((PyArray_TYPE(arr)) == NPY_OBJECT) && PyArray_SIZE(arr)PyArray_MultiplyList(PyArray_DIMS(arr), PyArray_NDIM(arr)) != 0) {
          Py_DECREF(initial)_Py_DECREF(((PyObject*)(initial)));
          initial = Py_None(&_Py_NoneStruct);
          Py_INCREF(initial)_Py_INCREF(((PyObject*)(initial)));
      }
  } else {
      Py_DECREF(identity)_Py_DECREF(((PyObject*)(identity)));
      Py_INCREF(initial)_Py_INCREF(((PyObject*)(initial)));  /* match the reference count in the if above */
  }

  /* Get the reduction dtype */
  if (reduce_type_resolver(ufunc, arr, odtype, &dtype) < 0) {
      Py_DECREF(initial)_Py_DECREF(((PyObject*)(initial)));
      return NULL((void*)0);
  }

  result = PyUFunc_ReduceWrapper(arr, out, wheremask, dtype, dtype,
                                 NPY_UNSAFE_CASTING,
                                 axis_flags, reorderable,
                                 keepdims,
                                 initial,
                                 reduce_loop,
                                 ufunc, buffersize, ufunc_name, errormask);

  Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
  Py_DECREF(initial)_Py_DECREF(((PyObject*)(initial)));
  return result;
3174}


3177static PyObject *
3178PyUFunc_Accumulate(PyUFuncObject *ufunc, PyArrayObject *arr, PyArrayObject *out,
                 int axis, int otype)
3180{
  PyArrayObject *op[2];
  PyArray_Descr *op_dtypes[2] = {NULL((void*)0), NULL((void*)0)};
  int op_axes_arrays[2][NPY_MAXDIMS32];
  int *op_axes[2] = {op_axes_arrays[0], op_axes_arrays[1]};
  npy_uint32 op_flags[2];
  int idim, ndim, otype_final;
  int needs_api, need_outer_iterator;

  NpyIter *iter = NULL((void*)0), *iter_inner = NULL((void*)0);

  /* The selected inner loop */
  PyUFuncGenericFunction innerloop = NULL((void*)0);
  void *innerloopdata = NULL((void*)0);

  const char *ufunc_name = ufunc_get_name_cstr(ufunc);

  /* These parameters come from extobj= or from a TLS global */
  int buffersize = 0, errormask = 0;

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

  NPY_UF_DBG_PRINT1("\nEvaluating ufunc %s.accumulate\n", ufunc_name);

3204#if 0
  printf("Doing %s.accumulate on array with dtype :  ", ufunc_name)__printf_chk (2 - 1, "Doing %s.accumulate on array with dtype :  "
, ufunc_name);
  PyObject_Print((PyObject *)PyArray_DESCR(arr), stdoutstdout, 0);
  printf("\n")__printf_chk (2 - 1, "\n");
3208#endif

  if (_get_bufsize_errmask(NULL((void*)0), "accumulate", &buffersize, &errormask) < 0) {
      return NULL((void*)0);
  }

  /* Take a reference to out for later returning */
  Py_XINCREF(out)_Py_XINCREF(((PyObject*)(out)));

  otype_final = otype;
  if (get_binary_op_function(ufunc, &otype_final,
                              &innerloop, &innerloopdata) < 0) {
      PyArray_Descr *dtype = PyArray_DescrFromType(otype);
      PyErr_Format(PyExc_ValueError,
                   "could not find a matching type for %s.accumulate, "
                   "requested type has type code '%c'",
                          ufunc_name, dtype ? dtype->type : '-');
      Py_XDECREF(dtype)_Py_XDECREF(((PyObject*)(dtype)));
      goto fail;
  }

  ndim = PyArray_NDIM(arr);

  /*
   * Set up the output data type, using the input's exact
   * data type if the type number didn't change to preserve
   * metadata
   */
  if (PyArray_DESCR(arr)->type_num == otype_final) {
      if (PyArray_ISNBO(PyArray_DESCR(arr)->byteorder)((PyArray_DESCR(arr)->byteorder) != '>')) {
          op_dtypes[0] = PyArray_DESCR(arr);
          Py_INCREF(op_dtypes[0])_Py_INCREF(((PyObject*)(op_dtypes[0])));
      }
      else {
          op_dtypes[0] = PyArray_DescrNewByteorder(PyArray_DESCR(arr),
                                                  NPY_NATIVE'=');
      }
  }
  else {
      op_dtypes[0] = PyArray_DescrFromType(otype_final);
  }
  if (op_dtypes[0] == NULL((void*)0)) {
      goto fail;
  }

3253#if NPY_UF_DBG_TRACING0
  printf("Found %s.accumulate inner loop with dtype :  ", ufunc_name)__printf_chk (2 - 1, "Found %s.accumulate inner loop with dtype :  "
, ufunc_name);
  PyObject_Print((PyObject *)op_dtypes[0], stdoutstdout, 0);
  printf("\n")__printf_chk (2 - 1, "\n");
3257#endif

  /* Set up the op_axes for the outer loop */
  for (idim = 0; idim < ndim; ++idim) {
      op_axes_arrays[0][idim] = idim;
      op_axes_arrays[1][idim] = idim;
  }

  /* The per-operand flags for the outer loop */
  op_flags[0] = NPY_ITER_READWRITE0x00010000 |
                NPY_ITER_NO_BROADCAST0x08000000 |
                NPY_ITER_ALLOCATE0x01000000 |
                NPY_ITER_NO_SUBTYPE0x02000000;
  op_flags[1] = NPY_ITER_READONLY0x00020000;

  op[0] = out;
  op[1] = arr;

  need_outer_iterator = (ndim > 1);
  /* We can't buffer, so must do UPDATEIFCOPY */
  if (!PyArray_ISALIGNED(arr)PyArray_CHKFLAGS((arr), 0x0100) || (out && !PyArray_ISALIGNED(out)PyArray_CHKFLAGS((out), 0x0100)) ||
          !PyArray_EquivTypes(op_dtypes[0], PyArray_DESCR(arr)) ||
          (out &&
           !PyArray_EquivTypes(op_dtypes[0], PyArray_DESCR(out)))) {
      need_outer_iterator = 1;
  }
  /* If input and output overlap in memory, use iterator to figure it out */
  else if (out != NULL((void*)0) && solve_may_share_memory(out, arr, NPY_MAY_SHARE_BOUNDS0) != 0) {
      need_outer_iterator = 1;
  }

  if (need_outer_iterator) {
      int ndim_iter = 0;
      npy_uint32 flags = NPY_ITER_ZEROSIZE_OK0x00000040|
                         NPY_ITER_REFS_OK0x00000020|
                         NPY_ITER_COPY_IF_OVERLAP0x00002000;
      PyArray_Descr **op_dtypes_param = NULL((void*)0);

      /*
       * The way accumulate is set up, we can't do buffering,
       * so make a copy instead when necessary.
       */
      ndim_iter = ndim;
      flags |= NPY_ITER_MULTI_INDEX0x00000004;
      /*
       * Add some more flags.
       *
       * The accumulation outer loop is 'elementwise' over the array, so turn
       * on NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE. That is, in-place
       * accumulate(x, out=x) is safe to do without temporary copies.
       */
      op_flags[0] |= NPY_ITER_UPDATEIFCOPY0x00800000|NPY_ITER_ALIGNED0x00100000|NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE0x40000000;
      op_flags[1] |= NPY_ITER_COPY0x00400000|NPY_ITER_ALIGNED0x00100000|NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE0x40000000;
      op_dtypes_param = op_dtypes;
      op_dtypes[1] = op_dtypes[0];
      NPY_UF_DBG_PRINT("Allocating outer iterator\n");
      iter = NpyIter_AdvancedNew(2, op, flags,
                                 NPY_KEEPORDER, NPY_UNSAFE_CASTING,
                                 op_flags,
                                 op_dtypes_param,
                                 ndim_iter, op_axes, NULL((void*)0), 0);
      if (iter == NULL((void*)0)) {
          goto fail;
      }

      /* In case COPY or UPDATEIFCOPY occurred */
      op[0] = NpyIter_GetOperandArray(iter)[0];
      op[1] = NpyIter_GetOperandArray(iter)[1];

      if (NpyIter_RemoveAxis(iter, axis) != NPY_SUCCEED1) {
          goto fail;
      }
      if (NpyIter_RemoveMultiIndex(iter) != NPY_SUCCEED1) {
          goto fail;
      }
  }

  /* Get the output */
  if (out == NULL((void*)0)) {
      if (iter) {
          op[0] = out = NpyIter_GetOperandArray(iter)[0];
          Py_INCREF(out)_Py_INCREF(((PyObject*)(out)));
      }
      else {
          PyArray_Descr *dtype = op_dtypes[0];
          Py_INCREF(dtype)_Py_INCREF(((PyObject*)(dtype)));
          op[0] = out = (PyArrayObject *)PyArray_NewFromDescr(
                                  &PyArray_Type, dtype,
                                  ndim, PyArray_DIMS(op[1]), NULL((void*)0), NULL((void*)0),
                                  0, NULL((void*)0));
          if (out == NULL((void*)0)) {
              goto fail;
          }

      }
  }

  /*
   * If the reduction axis has size zero, either return the reduction
   * unit for UFUNC_REDUCE, or return the zero-sized output array
   * for UFUNC_ACCUMULATE.
   */
  if (PyArray_DIM(op[1], axis) == 0) {
      goto finish;
  }
  else if (PyArray_SIZE(op[0])PyArray_MultiplyList(PyArray_DIMS(op[0]), PyArray_NDIM(op[0])
) == 0) {
      goto finish;
  }

  if (iter && NpyIter_GetIterSize(iter) != 0) {
      char *dataptr_copy[3];
      npy_intp stride_copy[3];
      npy_intp count_m1, stride0, stride1;

      NpyIter_IterNextFunc *iternext;
      char **dataptr;

      int itemsize = op_dtypes[0]->elsize;

      /* Get the variables needed for the loop */
      iternext = NpyIter_GetIterNext(iter, NULL((void*)0));
      if (iternext == NULL((void*)0)) {
          goto fail;
      }
      dataptr = NpyIter_GetDataPtrArray(iter);
      needs_api = NpyIter_IterationNeedsAPI(iter);


      /* Execute the loop with just the outer iterator */
      count_m1 = PyArray_DIM(op[1], axis)-1;
      stride0 = 0, stride1 = PyArray_STRIDE(op[1], axis);

      NPY_UF_DBG_PRINT("UFunc: Reduce loop with just outer iterator\n");

      stride0 = PyArray_STRIDE(op[0], axis);

      stride_copy[0] = stride0;
      stride_copy[1] = stride1;
      stride_copy[2] = stride0;

      NPY_BEGIN_THREADS_NDITER(iter)do { if (!NpyIter_IterationNeedsAPI(iter)) { do { if ((NpyIter_GetIterSize
(iter)) > 500) { _save = PyEval_SaveThread();} } while (0)
;; } } while(0);

      do {
          dataptr_copy[0] = dataptr[0];
          dataptr_copy[1] = dataptr[1];
          dataptr_copy[2] = dataptr[0];

          /*
           * Copy the first element to start the reduction.
           *
           * Output (dataptr[0]) and input (dataptr[1]) may point to
           * the same memory, e.g. np.add.accumulate(a, out=a).
           */
          if (otype == NPY_OBJECT) {
              /*
               * Incref before decref to avoid the possibility of the
               * reference count being zero temporarily.
               */
              Py_XINCREF(*(PyObject **)dataptr_copy[1])_Py_XINCREF(((PyObject*)(*(PyObject **)dataptr_copy[1])));
              Py_XDECREF(*(PyObject **)dataptr_copy[0])_Py_XDECREF(((PyObject*)(*(PyObject **)dataptr_copy[0])));
              *(PyObject **)dataptr_copy[0] =
                                  *(PyObject **)dataptr_copy[1];
          }
          else {
              memmove(dataptr_copy[0], dataptr_copy[1], itemsize);
          }

          if (count_m1 > 0) {
              /* Turn the two items into three for the inner loop */
              dataptr_copy[1] += stride1;
              dataptr_copy[2] += stride0;
              NPY_UF_DBG_PRINT1("iterator loop count %d\n",
                                              (int)count_m1);
              innerloop(dataptr_copy, &count_m1,
                          stride_copy, innerloopdata);
          }
      } while (!(needs_api && PyErr_Occurred()) && iternext(iter));

      NPY_END_THREADSdo { if (_save) { PyEval_RestoreThread(_save); _save = ((void
*)0);} } while (0);;
  }
  else if (iter == NULL((void*)0)) {
      char *dataptr_copy[3];
      npy_intp stride_copy[3];

      int itemsize = op_dtypes[0]->elsize;

      /* Execute the loop with no iterators */
      npy_intp count = PyArray_DIM(op[1], axis);
      npy_intp stride0 = 0, stride1 = PyArray_STRIDE(op[1], axis);

      NPY_UF_DBG_PRINT("UFunc: Reduce loop with no iterators\n");

      if (PyArray_NDIM(op[0]) != PyArray_NDIM(op[1]) ||
              !PyArray_CompareLists(PyArray_DIMS(op[0]),
                                    PyArray_DIMS(op[1]),
                                    PyArray_NDIM(op[0]))) {
          PyErr_SetString(PyExc_ValueError,
                  "provided out is the wrong size "
                  "for the reduction");
          goto fail;
      }
      stride0 = PyArray_STRIDE(op[0], axis);

      stride_copy[0] = stride0;
      stride_copy[1] = stride1;
      stride_copy[2] = stride0;

      /* Turn the two items into three for the inner loop */
      dataptr_copy[0] = PyArray_BYTES(op[0]);
      dataptr_copy[1] = PyArray_BYTES(op[1]);
      dataptr_copy[2] = PyArray_BYTES(op[0]);

      /*
       * Copy the first element to start the reduction.
       *
       * Output (dataptr[0]) and input (dataptr[1]) may point to the
       * same memory, e.g. np.add.accumulate(a, out=a).
       */
      if (otype == NPY_OBJECT) {
          /*
           * Incref before decref to avoid the possibility of the
           * reference count being zero temporarily.
           */
          Py_XINCREF(*(PyObject **)dataptr_copy[1])_Py_XINCREF(((PyObject*)(*(PyObject **)dataptr_copy[1])));
          Py_XDECREF(*(PyObject **)dataptr_copy[0])_Py_XDECREF(((PyObject*)(*(PyObject **)dataptr_copy[0])));
          *(PyObject **)dataptr_copy[0] =
                              *(PyObject **)dataptr_copy[1];
      }
      else {
          memmove(dataptr_copy[0], dataptr_copy[1], itemsize);
      }

      if (count > 1) {
          --count;
          dataptr_copy[1] += stride1;
          dataptr_copy[2] += stride0;

          NPY_UF_DBG_PRINT1("iterator loop count %d\n", (int)count);

          needs_api = PyDataType_REFCHK(op_dtypes[0])(((op_dtypes[0])->flags & (0x01)) == (0x01));

          if (!needs_api) {
              NPY_BEGIN_THREADS_THRESHOLDED(count)do { if ((count) > 500) { _save = PyEval_SaveThread();} } while
 (0);;
          }

          innerloop(dataptr_copy, &count,
                      stride_copy, innerloopdata);

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

3509finish:
  Py_XDECREF(op_dtypes[0])_Py_XDECREF(((PyObject*)(op_dtypes[0])));
  int res = 0;
  if (!NpyIter_Deallocate(iter)) {
      res = -1;
  }
  if (!NpyIter_Deallocate(iter_inner)) {
      res = -1;
  }
  if (res < 0) {
      Py_DECREF(out)_Py_DECREF(((PyObject*)(out)));
      return NULL((void*)0);
  }

  return (PyObject *)out;

3525fail:
  Py_XDECREF(out)_Py_XDECREF(((PyObject*)(out)));
  Py_XDECREF(op_dtypes[0])_Py_XDECREF(((PyObject*)(op_dtypes[0])));

  NpyIter_Deallocate(iter);
  NpyIter_Deallocate(iter_inner);

  return NULL((void*)0);
3533}

3535/*
* Reduceat performs a reduce over an axis using the indices as a guide
*
* op.reduceat(array,indices)  computes
* op.reduce(array[indices[i]:indices[i+1]]
* for i=0..end with an implicit indices[i+1]=len(array)
* assumed when i=end-1
*
* if indices[i+1] <= indices[i]+1
* then the result is array[indices[i]] for that value
*
* op.accumulate(array) is the same as
* op.reduceat(array,indices)[::2]
* where indices is range(len(array)-1) with a zero placed in every other sample
* indices = zeros(len(array)*2-1)
* indices[1::2] = range(1,len(array))
*
* output shape is based on the size of indices
*/
3554static PyObject *
3555PyUFunc_Reduceat(PyUFuncObject *ufunc, PyArrayObject *arr, PyArrayObject *ind,
               PyArrayObject *out, int axis, int otype)
3557{
  PyArrayObject *op[3];
  PyArray_Descr *op_dtypes[3] = {NULL((void*)0), NULL((void*)0), NULL((void*)0)};
  int op_axes_arrays[3][NPY_MAXDIMS32];
  int *op_axes[3] = {op_axes_arrays[0], op_axes_arrays[1],
                          op_axes_arrays[2]};
  npy_uint32 op_flags[3];
  int idim, ndim, otype_final;
  int need_outer_iterator = 0;

  NpyIter *iter = NULL((void*)0);

  /* The reduceat indices - ind must be validated outside this call */
  npy_intp *reduceat_ind;
  npy_intp i, ind_size, red_axis_size;
  /* The selected inner loop */
  PyUFuncGenericFunction innerloop = NULL((void*)0);
  void *innerloopdata = NULL((void*)0);

  const char *ufunc_name = ufunc_get_name_cstr(ufunc);
  char *opname = "reduceat";

  /* These parameters come from extobj= or from a TLS global */
  int buffersize = 0, errormask = 0;

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

  reduceat_ind = (npy_intp *)PyArray_DATA(ind);
  ind_size = PyArray_DIM(ind, 0);
  red_axis_size = PyArray_DIM(arr, axis);

  /* Check for out-of-bounds values in indices array */
  for (i = 0; i < ind_size; ++i) {
      if (reduceat_ind[i] < 0 || reduceat_ind[i] >= red_axis_size) {
          PyErr_Format(PyExc_IndexError,
              "index %" NPY_INTP_FMT"ld" " out-of-bounds in %s.%s [0, %" NPY_INTP_FMT"ld" ")",
              reduceat_ind[i], ufunc_name, opname, red_axis_size);
          return NULL((void*)0);
      }
  }

  NPY_UF_DBG_PRINT2("\nEvaluating ufunc %s.%s\n", ufunc_name, opname);

3600#if 0
  printf("Doing %s.%s on array with dtype :  ", ufunc_name, opname)__printf_chk (2 - 1, "Doing %s.%s on array with dtype :  ", ufunc_name
, opname);
  PyObject_Print((PyObject *)PyArray_DESCR(arr), stdoutstdout, 0);
  printf("\n")__printf_chk (2 - 1, "\n");
  printf("Index size is %d\n", (int)ind_size)__printf_chk (2 - 1, "Index size is %d\n", (int)ind_size);
3605#endif

  if (_get_bufsize_errmask(NULL((void*)0), opname, &buffersize, &errormask) < 0) {
      return NULL((void*)0);
  }

  /* Take a reference to out for later returning */
  Py_XINCREF(out)_Py_XINCREF(((PyObject*)(out)));

  otype_final = otype;
  if (get_binary_op_function(ufunc, &otype_final,
                              &innerloop, &innerloopdata) < 0) {
      PyArray_Descr *dtype = PyArray_DescrFromType(otype);
      PyErr_Format(PyExc_ValueError,
                   "could not find a matching type for %s.%s, "
                   "requested type has type code '%c'",
                          ufunc_name, opname, dtype ? dtype->type : '-');
      Py_XDECREF(dtype)_Py_XDECREF(((PyObject*)(dtype)));
      goto fail;
  }

  ndim = PyArray_NDIM(arr);

  /*
   * Set up the output data type, using the input's exact
   * data type if the type number didn't change to preserve
   * metadata
   */
  if (PyArray_DESCR(arr)->type_num == otype_final) {
      if (PyArray_ISNBO(PyArray_DESCR(arr)->byteorder)((PyArray_DESCR(arr)->byteorder) != '>')) {
          op_dtypes[0] = PyArray_DESCR(arr);
          Py_INCREF(op_dtypes[0])_Py_INCREF(((PyObject*)(op_dtypes[0])));
      }
      else {
          op_dtypes[0] = PyArray_DescrNewByteorder(PyArray_DESCR(arr),
                                                  NPY_NATIVE'=');
      }
  }
  else {
      op_dtypes[0] = PyArray_DescrFromType(otype_final);
  }
  if (op_dtypes[0] == NULL((void*)0)) {
      goto fail;
  }

3650#if NPY_UF_DBG_TRACING0
  printf("Found %s.%s inner loop with dtype :  ", ufunc_name, opname)__printf_chk (2 - 1, "Found %s.%s inner loop with dtype :  ",
 ufunc_name, opname);
  PyObject_Print((PyObject *)op_dtypes[0], stdoutstdout, 0);
  printf("\n")__printf_chk (2 - 1, "\n");
3654#endif

  /* Set up the op_axes for the outer loop */
  for (idim = 0; idim < ndim; ++idim) {
      /* Use the i-th iteration dimension to match up ind */
      if (idim == axis) {
          op_axes_arrays[0][idim] = axis;
          op_axes_arrays[1][idim] = -1;
          op_axes_arrays[2][idim] = 0;
      }
      else {
          op_axes_arrays[0][idim] = idim;
          op_axes_arrays[1][idim] = idim;
          op_axes_arrays[2][idim] = -1;
      }
  }

  op[0] = out;
  op[1] = arr;
  op[2] = ind;

  if (out != NULL((void*)0) || ndim > 1 || !PyArray_ISALIGNED(arr)PyArray_CHKFLAGS((arr), 0x0100) ||
          !PyArray_EquivTypes(op_dtypes[0], PyArray_DESCR(arr))) {
      need_outer_iterator = 1;
  }

  if (need_outer_iterator) {
      npy_uint32 flags = NPY_ITER_ZEROSIZE_OK0x00000040|
                         NPY_ITER_REFS_OK0x00000020|
                         NPY_ITER_MULTI_INDEX0x00000004|
                         NPY_ITER_COPY_IF_OVERLAP0x00002000;

      /*
       * The way reduceat is set up, we can't do buffering,
       * so make a copy instead when necessary using
       * the UPDATEIFCOPY flag
       */

      /* The per-operand flags for the outer loop */
      op_flags[0] = NPY_ITER_READWRITE0x00010000|
                    NPY_ITER_NO_BROADCAST0x08000000|
                    NPY_ITER_ALLOCATE0x01000000|
                    NPY_ITER_NO_SUBTYPE0x02000000|
                    NPY_ITER_UPDATEIFCOPY0x00800000|
                    NPY_ITER_ALIGNED0x00100000;
      op_flags[1] = NPY_ITER_READONLY0x00020000|
                    NPY_ITER_COPY0x00400000|
                    NPY_ITER_ALIGNED0x00100000;
      op_flags[2] = NPY_ITER_READONLY0x00020000;

      op_dtypes[1] = op_dtypes[0];

      NPY_UF_DBG_PRINT("Allocating outer iterator\n");
      iter = NpyIter_AdvancedNew(3, op, flags,
                                 NPY_KEEPORDER, NPY_UNSAFE_CASTING,
                                 op_flags,
                                 op_dtypes,
                                 ndim, op_axes, NULL((void*)0), 0);
      if (iter == NULL((void*)0)) {
          goto fail;
      }

      /* Remove the inner loop axis from the outer iterator */
      if (NpyIter_RemoveAxis(iter, axis) != NPY_SUCCEED1) {
          goto fail;
      }
      if (NpyIter_RemoveMultiIndex(iter) != NPY_SUCCEED1) {
          goto fail;
      }

      /* In case COPY or UPDATEIFCOPY occurred */
      op[0] = NpyIter_GetOperandArray(iter)[0];
      op[1] = NpyIter_GetOperandArray(iter)[1];
      op[2] = NpyIter_GetOperandArray(iter)[2];

      if (out == NULL((void*)0)) {
          out = op[0];
          Py_INCREF(out)_Py_INCREF(((PyObject*)(out)));
      }
  }
  /* Allocate the output for when there's no outer iterator */
  else if (out == NULL((void*)0)) {
      Py_INCREF(op_dtypes[0])_Py_INCREF(((PyObject*)(op_dtypes[0])));
      op[0] = out = (PyArrayObject *)PyArray_NewFromDescr(
                                  &PyArray_Type, op_dtypes[0],
                                  1, &ind_size, NULL((void*)0), NULL((void*)0),
                                  0, NULL((void*)0));
      if (out == NULL((void*)0)) {
          goto fail;
      }
  }

  /*
   * If the output has zero elements, return now.
   */
  if (PyArray_SIZE(op[0])PyArray_MultiplyList(PyArray_DIMS(op[0]), PyArray_NDIM(op[0])
) == 0) {
      goto finish;
  }

  if (iter && NpyIter_GetIterSize(iter) != 0) {
      char *dataptr_copy[3];
      npy_intp stride_copy[3];

      NpyIter_IterNextFunc *iternext;
      char **dataptr;
      npy_intp count_m1;
      npy_intp stride0, stride1;
      npy_intp stride0_ind = PyArray_STRIDE(op[0], axis);

      int itemsize = op_dtypes[0]->elsize;
      int needs_api = NpyIter_IterationNeedsAPI(iter);

      /* Get the variables needed for the loop */
      iternext = NpyIter_GetIterNext(iter, NULL((void*)0));
      if (iternext == NULL((void*)0)) {
          goto fail;
      }
      dataptr = NpyIter_GetDataPtrArray(iter);

      /* Execute the loop with just the outer iterator */
      count_m1 = PyArray_DIM(op[1], axis)-1;
      stride0 = 0;
      stride1 = PyArray_STRIDE(op[1], axis);

      NPY_UF_DBG_PRINT("UFunc: Reduce loop with just outer iterator\n");

      stride_copy[0] = stride0;
      stride_copy[1] = stride1;
      stride_copy[2] = stride0;

      NPY_BEGIN_THREADS_NDITER(iter)do { if (!NpyIter_IterationNeedsAPI(iter)) { do { if ((NpyIter_GetIterSize
(iter)) > 500) { _save = PyEval_SaveThread();} } while (0)
;; } } while(0);

      do {

          for (i = 0; i < ind_size; ++i) {
              npy_intp start = reduceat_ind[i],
                      end = (i == ind_size-1) ? count_m1+1 :
                                                reduceat_ind[i+1];
              npy_intp count = end - start;

              dataptr_copy[0] = dataptr[0] + stride0_ind*i;
              dataptr_copy[1] = dataptr[1] + stride1*start;
              dataptr_copy[2] = dataptr[0] + stride0_ind*i;

              /*
               * Copy the first element to start the reduction.
               *
               * Output (dataptr[0]) and input (dataptr[1]) may point
               * to the same memory, e.g.
               * np.add.reduceat(a, np.arange(len(a)), out=a).
               */
              if (otype == NPY_OBJECT) {
                  /*
                   * Incref before decref to avoid the possibility of
                   * the reference count being zero temporarily.
                   */
                  Py_XINCREF(*(PyObject **)dataptr_copy[1])_Py_XINCREF(((PyObject*)(*(PyObject **)dataptr_copy[1])));
                  Py_XDECREF(*(PyObject **)dataptr_copy[0])_Py_XDECREF(((PyObject*)(*(PyObject **)dataptr_copy[0])));
                  *(PyObject **)dataptr_copy[0] =
                                      *(PyObject **)dataptr_copy[1];
              }
              else {
                  memmove(dataptr_copy[0], dataptr_copy[1], itemsize);
              }

              if (count > 1) {
                  /* Inner loop like REDUCE */
                  --count;
                  dataptr_copy[1] += stride1;
                  NPY_UF_DBG_PRINT1("iterator loop count %d\n",
                                                  (int)count);
                  innerloop(dataptr_copy, &count,
                              stride_copy, innerloopdata);
              }
          }
      } while (!(needs_api && PyErr_Occurred()) && iternext(iter));

      NPY_END_THREADSdo { if (_save) { PyEval_RestoreThread(_save); _save = ((void
*)0);} } while (0);;
  }
  else if (iter == NULL((void*)0)) {
      char *dataptr_copy[3];
      npy_intp stride_copy[3];

      int itemsize = op_dtypes[0]->elsize;

      npy_intp stride0_ind = PyArray_STRIDE(op[0], axis);

      /* Execute the loop with no iterators */
      npy_intp stride0 = 0, stride1 = PyArray_STRIDE(op[1], axis);

      int needs_api = PyDataType_REFCHK(op_dtypes[0])(((op_dtypes[0])->flags & (0x01)) == (0x01));

      NPY_UF_DBG_PRINT("UFunc: Reduce loop with no iterators\n");

      stride_copy[0] = stride0;
      stride_copy[1] = stride1;
      stride_copy[2] = stride0;

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

      for (i = 0; i < ind_size; ++i) {
          npy_intp start = reduceat_ind[i],
                  end = (i == ind_size-1) ? PyArray_DIM(arr,axis) :
                                            reduceat_ind[i+1];
          npy_intp count = end - start;

          dataptr_copy[0] = PyArray_BYTES(op[0]) + stride0_ind*i;
          dataptr_copy[1] = PyArray_BYTES(op[1]) + stride1*start;
          dataptr_copy[2] = PyArray_BYTES(op[0]) + stride0_ind*i;

          /*
           * Copy the first element to start the reduction.
           *
           * Output (dataptr[0]) and input (dataptr[1]) may point to
           * the same memory, e.g.
           * np.add.reduceat(a, np.arange(len(a)), out=a).
           */
          if (otype == NPY_OBJECT) {
              /*
               * Incref before decref to avoid the possibility of the
               * reference count being zero temporarily.
               */
              Py_XINCREF(*(PyObject **)dataptr_copy[1])_Py_XINCREF(((PyObject*)(*(PyObject **)dataptr_copy[1])));
              Py_XDECREF(*(PyObject **)dataptr_copy[0])_Py_XDECREF(((PyObject*)(*(PyObject **)dataptr_copy[0])));
              *(PyObject **)dataptr_copy[0] =
                                  *(PyObject **)dataptr_copy[1];
          }
          else {
              memmove(dataptr_copy[0], dataptr_copy[1], itemsize);
          }

          if (count > 1) {
              /* Inner loop like REDUCE */
              --count;
              dataptr_copy[1] += stride1;
              NPY_UF_DBG_PRINT1("iterator loop count %d\n",
                                              (int)count);
              innerloop(dataptr_copy, &count,
                          stride_copy, innerloopdata);
          }
      }

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

3901finish:
  Py_XDECREF(op_dtypes[0])_Py_XDECREF(((PyObject*)(op_dtypes[0])));
  if (!NpyIter_Deallocate(iter)) {
      Py_DECREF(out)_Py_DECREF(((PyObject*)(out)));
      return NULL((void*)0);
  }

  return (PyObject *)out;

3910fail:
  Py_XDECREF(out)_Py_XDECREF(((PyObject*)(out)));
  Py_XDECREF(op_dtypes[0])_Py_XDECREF(((PyObject*)(op_dtypes[0])));

  NpyIter_Deallocate(iter);
  return NULL((void*)0);
3916}


3919static npy_bool
3920tuple_all_none(PyObject *tup) {
  npy_intp i;
  for (i = 0; i < PyTuple_GET_SIZE(tup)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(tup))))->
ob_size); ++i) {
      if (PyTuple_GET_ITEM(tup, i)((((void) (0)), (PyTupleObject *)(tup))->ob_item[i]) != Py_None(&_Py_NoneStruct)) {
          return NPY_FALSE0;
      }
  }
  return NPY_TRUE1;
3928}


3931static int
3932_set_full_args_out(int nout, PyObject *out_obj, ufunc_full_args *full_args)
3933{
  if (PyTuple_CheckExact(out_obj)((((PyObject*)(out_obj))->ob_type) == &PyTuple_Type)) {
      if (PyTuple_GET_SIZE(out_obj)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(out_obj))))
->ob_size) != nout) {
          PyErr_SetString(PyExc_ValueError,
                          "The 'out' tuple must have exactly "
                          "one entry per ufunc output");
          return -1;
      }
      if (tuple_all_none(out_obj)) {
          return 0;
      }
      else {
          Py_INCREF(out_obj)_Py_INCREF(((PyObject*)(out_obj)));
          full_args->out = out_obj;
      }
  }
  else if (nout == 1) {
      if (out_obj == Py_None(&_Py_NoneStruct)) {
          return 0;
      }
      /* Can be an array if it only has one output */
      full_args->out = PyTuple_Pack(1, out_obj);
      if (full_args->out == NULL((void*)0)) {
          return -1;
      }
  }
  else {
      PyErr_SetString(PyExc_TypeError,
                      nout > 1 ? "'out' must be a tuple of arrays" :
                      "'out' must be an array or a tuple with "
                      "a single array");
      return -1;
  }
  return 0;
3967}


3970/*
* Convert function which replaces np._NoValue with NULL.
* As a converter returns 0 on error and 1 on success.
*/
3974static int
3975_not_NoValue(PyObject *obj, PyObject **out)
3976{
  static PyObject *NoValue = NULL((void*)0);
  npy_cache_import("numpy", "_NoValue", &NoValue);
  if (NoValue == NULL((void*)0)) {
      return 0;
  }
  if (obj == NoValue) {
      *out = NULL((void*)0);
  }
  else {
      *out = obj;
  }
  return 1;
3989}


3992/* forward declaration */
3993static PyArray_DTypeMeta * _get_dtype(PyObject *dtype_obj);

3995/*
* This code handles reduce, reduceat, and accumulate
* (accumulate and reduce are special cases of the more general reduceat
* but they are handled separately for speed)
*/
4000static PyObject *
4001PyUFunc_GenericReduction(PyUFuncObject *ufunc,
      PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames, int operation)
4003{
  int i, naxes=0, ndim;
  int axes[NPY_MAXDIMS32];

  ufunc_full_args full_args = {NULL((void*)0), NULL((void*)0)};
  PyObject *axes_obj = NULL((void*)0);
  PyArrayObject *mp = NULL((void*)0), *wheremask = NULL((void*)0), *ret = NULL((void*)0);
  PyObject *op = NULL((void*)0);
  PyArrayObject *indices = NULL((void*)0);
  PyArray_Descr *otype = NULL((void*)0);
  PyArrayObject *out = NULL((void*)0);
  int keepdims = 0;
  PyObject *initial = NULL((void*)0);
  npy_bool out_is_passed_by_position;


  static char *_reduce_type[] = {"reduce", "accumulate", "reduceat", NULL((void*)0)};

  if (ufunc == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError, "function not supported");
      return NULL((void*)0);
  }
  if (ufunc->core_enabled) {
      PyErr_Format(PyExc_RuntimeError,
                   "Reduction not defined on ufunc with signature");
      return NULL((void*)0);
  }
  if (ufunc->nin != 2) {
      PyErr_Format(PyExc_ValueError,
                   "%s only supported for binary functions",
                   _reduce_type[operation]);
      return NULL((void*)0);
  }
  if (ufunc->nout != 1) {
      PyErr_Format(PyExc_ValueError,
                   "%s only supported for functions "
                   "returning a single value",
                   _reduce_type[operation]);
      return NULL((void*)0);
  }

  /*
   * Perform argument parsing, but start by only extracting. This is
   * just to preserve the behaviour that __array_ufunc__ did not perform
   * any checks on arguments, and we could change this or change it for
   * certain parameters.
   */
  PyObject *otype_obj = NULL((void*)0), *out_obj = NULL((void*)0), *indices_obj = NULL((void*)0);
  PyObject *keepdims_obj = NULL((void*)0), *wheremask_obj = NULL((void*)0);
  if (operation == UFUNC_REDUCEAT2) {
      NPY_PREPARE_ARGPARSERstatic _NpyArgParserCache __argparse_cache = {-1};

      if (npy_parse_arguments("reduceat", args, len_args, kwnames,_npy_parse_arguments("reduceat", &__argparse_cache, args,
 len_args, kwnames, "array", ((void*)0), &op, "indices", (
(void*)0), &indices_obj, "|axis", ((void*)0), &axes_obj
, "|dtype", ((void*)0), &otype_obj, "|out", ((void*)0), &
out_obj, ((void*)0), ((void*)0), ((void*)0))
              "array", NULL, &op,_npy_parse_arguments("reduceat", &__argparse_cache, args,
 len_args, kwnames, "array", ((void*)0), &op, "indices", (
(void*)0), &indices_obj, "|axis", ((void*)0), &axes_obj
, "|dtype", ((void*)0), &otype_obj, "|out", ((void*)0), &
out_obj, ((void*)0), ((void*)0), ((void*)0))
              "indices", NULL, &indices_obj,_npy_parse_arguments("reduceat", &__argparse_cache, args,
 len_args, kwnames, "array", ((void*)0), &op, "indices", (
(void*)0), &indices_obj, "|axis", ((void*)0), &axes_obj
, "|dtype", ((void*)0), &otype_obj, "|out", ((void*)0), &
out_obj, ((void*)0), ((void*)0), ((void*)0))
              "|axis", NULL, &axes_obj,_npy_parse_arguments("reduceat", &__argparse_cache, args,
 len_args, kwnames, "array", ((void*)0), &op, "indices", (
(void*)0), &indices_obj, "|axis", ((void*)0), &axes_obj
, "|dtype", ((void*)0), &otype_obj, "|out", ((void*)0), &
out_obj, ((void*)0), ((void*)0), ((void*)0))
              "|dtype", NULL, &otype_obj,_npy_parse_arguments("reduceat", &__argparse_cache, args,
 len_args, kwnames, "array", ((void*)0), &op, "indices", (
(void*)0), &indices_obj, "|axis", ((void*)0), &axes_obj
, "|dtype", ((void*)0), &otype_obj, "|out", ((void*)0), &
out_obj, ((void*)0), ((void*)0), ((void*)0))
              "|out", NULL, &out_obj,_npy_parse_arguments("reduceat", &__argparse_cache, args,
 len_args, kwnames, "array", ((void*)0), &op, "indices", (
(void*)0), &indices_obj, "|axis", ((void*)0), &axes_obj
, "|dtype", ((void*)0), &otype_obj, "|out", ((void*)0), &
out_obj, ((void*)0), ((void*)0), ((void*)0))
              NULL, NULL, NULL)_npy_parse_arguments("reduceat", &__argparse_cache, args,
 len_args, kwnames, "array", ((void*)0), &op, "indices", (
(void*)0), &indices_obj, "|axis", ((void*)0), &axes_obj
, "|dtype", ((void*)0), &otype_obj, "|out", ((void*)0), &
out_obj, ((void*)0), ((void*)0), ((void*)0)) < 0) {
          goto fail;
      }
      /* Prepare inputs for PyUfunc_CheckOverride */
      full_args.in = PyTuple_Pack(2, op, indices_obj);
      if (full_args.in == NULL((void*)0)) {
          goto fail;
      }
      out_is_passed_by_position = len_args >= 5;
  }
  else if (operation == UFUNC_ACCUMULATE1) {
      NPY_PREPARE_ARGPARSERstatic _NpyArgParserCache __argparse_cache = {-1};

      if (npy_parse_arguments("accumulate", args, len_args, kwnames,_npy_parse_arguments("accumulate", &__argparse_cache, args
, len_args, kwnames, "array", ((void*)0), &op, "|axis", (
(void*)0), &axes_obj, "|dtype", ((void*)0), &otype_obj
, "|out", ((void*)0), &out_obj, ((void*)0), ((void*)0), (
(void*)0))
              "array", NULL, &op,_npy_parse_arguments("accumulate", &__argparse_cache, args
, len_args, kwnames, "array", ((void*)0), &op, "|axis", (
(void*)0), &axes_obj, "|dtype", ((void*)0), &otype_obj
, "|out", ((void*)0), &out_obj, ((void*)0), ((void*)0), (
(void*)0))
              "|axis", NULL, &axes_obj,_npy_parse_arguments("accumulate", &__argparse_cache, args
, len_args, kwnames, "array", ((void*)0), &op, "|axis", (
(void*)0), &axes_obj, "|dtype", ((void*)0), &otype_obj
, "|out", ((void*)0), &out_obj, ((void*)0), ((void*)0), (
(void*)0))
              "|dtype", NULL, &otype_obj,_npy_parse_arguments("accumulate", &__argparse_cache, args
, len_args, kwnames, "array", ((void*)0), &op, "|axis", (
(void*)0), &axes_obj, "|dtype", ((void*)0), &otype_obj
, "|out", ((void*)0), &out_obj, ((void*)0), ((void*)0), (
(void*)0))
              "|out", NULL, &out_obj,_npy_parse_arguments("accumulate", &__argparse_cache, args
, len_args, kwnames, "array", ((void*)0), &op, "|axis", (
(void*)0), &axes_obj, "|dtype", ((void*)0), &otype_obj
, "|out", ((void*)0), &out_obj, ((void*)0), ((void*)0), (
(void*)0))
              NULL, NULL, NULL)_npy_parse_arguments("accumulate", &__argparse_cache, args
, len_args, kwnames, "array", ((void*)0), &op, "|axis", (
(void*)0), &axes_obj, "|dtype", ((void*)0), &otype_obj
, "|out", ((void*)0), &out_obj, ((void*)0), ((void*)0), (
(void*)0)) < 0) {
          goto fail;
      }
      /* Prepare input for PyUfunc_CheckOverride */
      full_args.in = PyTuple_Pack(1, op);
      if (full_args.in == NULL((void*)0)) {
          goto fail;
      }
      out_is_passed_by_position = len_args >= 4;
  }
  else {
      NPY_PREPARE_ARGPARSERstatic _NpyArgParserCache __argparse_cache = {-1};

      if (npy_parse_arguments("reduce", args, len_args, kwnames,_npy_parse_arguments("reduce", &__argparse_cache, args, len_args
, kwnames, "array", ((void*)0), &op, "|axis", ((void*)0),
 &axes_obj, "|dtype", ((void*)0), &otype_obj, "|out",
 ((void*)0), &out_obj, "|keepdims", ((void*)0), &keepdims_obj
, "|initial", &_not_NoValue, &initial, "|where", ((void
*)0), &wheremask_obj, ((void*)0), ((void*)0), ((void*)0))
              "array", NULL, &op,_npy_parse_arguments("reduce", &__argparse_cache, args, len_args
, kwnames, "array", ((void*)0), &op, "|axis", ((void*)0),
 &axes_obj, "|dtype", ((void*)0), &otype_obj, "|out",
 ((void*)0), &out_obj, "|keepdims", ((void*)0), &keepdims_obj
, "|initial", &_not_NoValue, &initial, "|where", ((void
*)0), &wheremask_obj, ((void*)0), ((void*)0), ((void*)0))
              "|axis", NULL, &axes_obj,_npy_parse_arguments("reduce", &__argparse_cache, args, len_args
, kwnames, "array", ((void*)0), &op, "|axis", ((void*)0),
 &axes_obj, "|dtype", ((void*)0), &otype_obj, "|out",
 ((void*)0), &out_obj, "|keepdims", ((void*)0), &keepdims_obj
, "|initial", &_not_NoValue, &initial, "|where", ((void
*)0), &wheremask_obj, ((void*)0), ((void*)0), ((void*)0))
              "|dtype", NULL, &otype_obj,_npy_parse_arguments("reduce", &__argparse_cache, args, len_args
, kwnames, "array", ((void*)0), &op, "|axis", ((void*)0),
 &axes_obj, "|dtype", ((void*)0), &otype_obj, "|out",
 ((void*)0), &out_obj, "|keepdims", ((void*)0), &keepdims_obj
, "|initial", &_not_NoValue, &initial, "|where", ((void
*)0), &wheremask_obj, ((void*)0), ((void*)0), ((void*)0))
              "|out", NULL, &out_obj,_npy_parse_arguments("reduce", &__argparse_cache, args, len_args
, kwnames, "array", ((void*)0), &op, "|axis", ((void*)0),
 &axes_obj, "|dtype", ((void*)0), &otype_obj, "|out",
 ((void*)0), &out_obj, "|keepdims", ((void*)0), &keepdims_obj
, "|initial", &_not_NoValue, &initial, "|where", ((void
*)0), &wheremask_obj, ((void*)0), ((void*)0), ((void*)0))
              "|keepdims", NULL, &keepdims_obj,_npy_parse_arguments("reduce", &__argparse_cache, args, len_args
, kwnames, "array", ((void*)0), &op, "|axis", ((void*)0),
 &axes_obj, "|dtype", ((void*)0), &otype_obj, "|out",
 ((void*)0), &out_obj, "|keepdims", ((void*)0), &keepdims_obj
, "|initial", &_not_NoValue, &initial, "|where", ((void
*)0), &wheremask_obj, ((void*)0), ((void*)0), ((void*)0))
              "|initial", &_not_NoValue, &initial,_npy_parse_arguments("reduce", &__argparse_cache, args, len_args
, kwnames, "array", ((void*)0), &op, "|axis", ((void*)0),
 &axes_obj, "|dtype", ((void*)0), &otype_obj, "|out",
 ((void*)0), &out_obj, "|keepdims", ((void*)0), &keepdims_obj
, "|initial", &_not_NoValue, &initial, "|where", ((void
*)0), &wheremask_obj, ((void*)0), ((void*)0), ((void*)0))
              "|where", NULL, &wheremask_obj,_npy_parse_arguments("reduce", &__argparse_cache, args, len_args
, kwnames, "array", ((void*)0), &op, "|axis", ((void*)0),
 &axes_obj, "|dtype", ((void*)0), &otype_obj, "|out",
 ((void*)0), &out_obj, "|keepdims", ((void*)0), &keepdims_obj
, "|initial", &_not_NoValue, &initial, "|where", ((void
*)0), &wheremask_obj, ((void*)0), ((void*)0), ((void*)0))
              NULL, NULL, NULL)_npy_parse_arguments("reduce", &__argparse_cache, args, len_args
, kwnames, "array", ((void*)0), &op, "|axis", ((void*)0),
 &axes_obj, "|dtype", ((void*)0), &otype_obj, "|out",
 ((void*)0), &out_obj, "|keepdims", ((void*)0), &keepdims_obj
, "|initial", &_not_NoValue, &initial, "|where", ((void
*)0), &wheremask_obj, ((void*)0), ((void*)0), ((void*)0)) < 0) {
          goto fail;
      }
      /* Prepare input for PyUfunc_CheckOverride */
      full_args.in = PyTuple_Pack(1, op);
      if (full_args.in == NULL((void*)0)) {
          goto fail;
      }
      out_is_passed_by_position = len_args >= 4;
  }

  /* Normalize output for PyUFunc_CheckOverride and conversion. */
  if (out_is_passed_by_position) {
      /* in this branch, out is always wrapped in a tuple. */
      if (out_obj != Py_None(&_Py_NoneStruct)) {
          full_args.out = PyTuple_Pack(1, out_obj);
          if (full_args.out == NULL((void*)0)) {
              goto fail;
          }
      }
  }
  else if (out_obj) {
      if (_set_full_args_out(1, out_obj, &full_args) < 0) {
          goto fail;
      }
      /* Ensure that out_obj is the array, not the tuple: */
      if (full_args.out != NULL((void*)0)) {
          out_obj = PyTuple_GET_ITEM(full_args.out, 0)((((void) (0)), (PyTupleObject *)(full_args.out))->ob_item
[0]);
      }
  }

  /* We now have all the information required to check for Overrides */
  PyObject *override = NULL((void*)0);
  int errval = PyUFunc_CheckOverride(ufunc, _reduce_type[operation],
          full_args.in, full_args.out, args, len_args, kwnames, &override);
  if (errval) {
      return NULL((void*)0);
  }
  else if (override) {
      Py_XDECREF(full_args.in)_Py_XDECREF(((PyObject*)(full_args.in)));
      Py_XDECREF(full_args.out)_Py_XDECREF(((PyObject*)(full_args.out)));
      return override;
  }

  /* Finish parsing of all parameters (no matter which reduce-like) */
  if (indices_obj) {
      PyArray_Descr *indtype = PyArray_DescrFromType(NPY_INTPNPY_LONG);

      indices = (PyArrayObject *)PyArray_FromAny(indices_obj,
              indtype, 1, 1, NPY_ARRAY_CARRAY(0x0001 | (0x0100 | 0x0400)), NULL((void*)0));
      if (indices == NULL((void*)0)) {
          goto fail;
      }
  }
  if (otype_obj && otype_obj != Py_None(&_Py_NoneStruct)) {
      /* Use `_get_dtype` because `dtype` is a DType and not the instance */
      PyArray_DTypeMeta *dtype = _get_dtype(otype_obj);
      if (dtype == NULL((void*)0)) {
          goto fail;
      }
      Py_INCREF(dtype->singleton)_Py_INCREF(((PyObject*)(dtype->singleton)));
      otype = dtype->singleton;
  }
  if (out_obj && !PyArray_OutputConverter(out_obj, &out)) {
      goto fail;
  }
  if (keepdims_obj && !PyArray_PythonPyIntFromInt(keepdims_obj, &keepdims)) {
      goto fail;
  }
  if (wheremask_obj && !_wheremask_converter(wheremask_obj, &wheremask)) {
      goto fail;
  }

  /* Ensure input is an array */
  mp = (PyArrayObject *)PyArray_FromAny(op, NULL((void*)0), 0, 0, 0, NULL((void*)0));
  if (mp == NULL((void*)0)) {
      goto fail;
  }

  ndim = PyArray_NDIM(mp);

  /* Check to see that type (and otype) is not FLEXIBLE */
  if (PyArray_ISFLEXIBLE(mp)(((PyArray_TYPE(mp)) >=NPY_STRING) && ((PyArray_TYPE
(mp)) <=NPY_VOID)) ||
      (otype && PyTypeNum_ISFLEXIBLE(otype->type_num)(((otype->type_num) >=NPY_STRING) && ((otype->
type_num) <=NPY_VOID)))) {
      PyErr_Format(PyExc_TypeError,
                   "cannot perform %s with flexible type",
                   _reduce_type[operation]);
      goto fail;
  }

  /* Convert the 'axis' parameter into a list of axes */
  if (axes_obj == NULL((void*)0)) {
      /* apply defaults */
      if (ndim == 0) {
          naxes = 0;
      }
      else {
          naxes = 1;
          axes[0] = 0;
      }
  }
  else if (axes_obj == Py_None(&_Py_NoneStruct)) {
      /* Convert 'None' into all the axes */
      naxes = ndim;
      for (i = 0; i < naxes; ++i) {
          axes[i] = i;
      }
  }
  else if (PyTuple_Check(axes_obj)((((((PyObject*)(axes_obj))->ob_type))->tp_flags & (
(1UL << 26))) != 0)) {
      naxes = PyTuple_Size(axes_obj);
      if (naxes < 0 || naxes > NPY_MAXDIMS32) {
          PyErr_SetString(PyExc_ValueError,
                  "too many values for 'axis'");
          goto fail;
      }
      for (i = 0; i < naxes; ++i) {
          PyObject *tmp = PyTuple_GET_ITEM(axes_obj, i)((((void) (0)), (PyTupleObject *)(axes_obj))->ob_item[i]);
          int axis = PyArray_PyIntAsInt(tmp);
          if (error_converting(axis)(((axis) == -1) && PyErr_Occurred())) {
              goto fail;
          }
          if (check_and_adjust_axis(&axis, ndim) < 0) {
              goto fail;
          }
          axes[i] = (int)axis;
      }
  }
  else {
      /* Try to interpret axis as an integer */
      int axis = PyArray_PyIntAsInt(axes_obj);
      /* TODO: PyNumber_Index would be good to use here */
      if (error_converting(axis)(((axis) == -1) && PyErr_Occurred())) {
          goto fail;
      }
      /*
       * As a special case for backwards compatibility in 'sum',
       * 'prod', et al, also allow a reduction for scalars even
       * though this is technically incorrect.
       */
      if (ndim == 0 && (axis == 0 || axis == -1)) {
          naxes = 0;
      }
      else if (check_and_adjust_axis(&axis, ndim) < 0) {
          goto fail;
      }
      else {
          axes[0] = (int)axis;
          naxes = 1;
      }
  }

   /*
    * If out is specified it determines otype
    * unless otype already specified.
    */
  if (otype == NULL((void*)0) && out != NULL((void*)0)) {
      otype = PyArray_DESCR(out);
      Py_INCREF(otype)_Py_INCREF(((PyObject*)(otype)));
  }
  if (otype == NULL((void*)0)) {
      /*
       * For integer types --- make sure at least a long
       * is used for add and multiply reduction to avoid overflow
       */
      int typenum = PyArray_TYPE(mp);
      if ((PyTypeNum_ISBOOL(typenum)((typenum) == NPY_BOOL) || PyTypeNum_ISINTEGER(typenum)(((typenum) >= NPY_BYTE) && ((typenum) <= NPY_ULONGLONG
)))
          && ((strcmp(ufunc->name,"add") == 0)
              || (strcmp(ufunc->name,"multiply") == 0))) {
          if (PyTypeNum_ISBOOL(typenum)((typenum) == NPY_BOOL)) {
              typenum = NPY_LONG;
          }
          else if ((size_t)PyArray_DESCR(mp)->elsize < sizeof(long)) {
              if (PyTypeNum_ISUNSIGNED(typenum)(((typenum) == NPY_UBYTE) || ((typenum) == NPY_USHORT) || ((typenum
) == NPY_UINT) || ((typenum) == NPY_ULONG) || ((typenum) == NPY_ULONGLONG
))) {
                  typenum = NPY_ULONG;
              }
              else {
                  typenum = NPY_LONG;
              }
          }
      }
      otype = PyArray_DescrFromType(typenum);
  }


  switch(operation) {
  case UFUNC_REDUCE0:
      ret = PyUFunc_Reduce(ufunc, mp, out, naxes, axes,
                           otype, keepdims, initial, wheremask);
      Py_XDECREF(wheremask)_Py_XDECREF(((PyObject*)(wheremask)));
      break;
  case UFUNC_ACCUMULATE1:
      if (ndim == 0) {
          PyErr_SetString(PyExc_TypeError, "cannot accumulate on a scalar");
          goto fail;
      }
      if (naxes != 1) {
          PyErr_SetString(PyExc_ValueError,
                      "accumulate does not allow multiple axes");
          goto fail;
      }
      ret = (PyArrayObject *)PyUFunc_Accumulate(ufunc, mp, out, axes[0],
                                                otype->type_num);
      break;
  case UFUNC_REDUCEAT2:
      if (ndim == 0) {
          PyErr_SetString(PyExc_TypeError, "cannot reduceat on a scalar");
          goto fail;
      }
      if (naxes != 1) {
          PyErr_SetString(PyExc_ValueError,
                      "reduceat does not allow multiple axes");
          goto fail;
      }
      ret = (PyArrayObject *)PyUFunc_Reduceat(ufunc, mp, indices, out,
                                          axes[0], otype->type_num);
      Py_DECREF(indices)_Py_DECREF(((PyObject*)(indices)));
      break;
  }
  Py_DECREF(mp)_Py_DECREF(((PyObject*)(mp)));
  Py_DECREF(otype)_Py_DECREF(((PyObject*)(otype)));
  Py_XDECREF(full_args.in)_Py_XDECREF(((PyObject*)(full_args.in)));
  Py_XDECREF(full_args.out)_Py_XDECREF(((PyObject*)(full_args.out)));

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

  /* Wrap and return the output */
  {
      /* Find __array_wrap__ - note that these rules are different to the
       * normal ufunc path
       */
      PyObject *wrap;
      if (out != NULL((void*)0)) {
          wrap = Py_None(&_Py_NoneStruct);
          Py_INCREF(wrap)_Py_INCREF(((PyObject*)(wrap)));
      }
      else if (Py_TYPE(op)(((PyObject*)(op))->ob_type) != Py_TYPE(ret)(((PyObject*)(ret))->ob_type)) {
          wrap = PyObject_GetAttr(op, npy_um_str_array_wrap);
          if (wrap == NULL((void*)0)) {
              PyErr_Clear();
          }
          else if (!PyCallable_Check(wrap)) {
              Py_DECREF(wrap)_Py_DECREF(((PyObject*)(wrap)));
              wrap = NULL((void*)0);
          }
      }
      else {
          wrap = NULL((void*)0);
      }
      return _apply_array_wrap(wrap, ret, NULL((void*)0));
  }

4353fail:
  Py_XDECREF(otype)_Py_XDECREF(((PyObject*)(otype)));
  Py_XDECREF(mp)_Py_XDECREF(((PyObject*)(mp)));
  Py_XDECREF(wheremask)_Py_XDECREF(((PyObject*)(wheremask)));
  Py_XDECREF(full_args.in)_Py_XDECREF(((PyObject*)(full_args.in)));
  Py_XDECREF(full_args.out)_Py_XDECREF(((PyObject*)(full_args.out)));
  return NULL((void*)0);
4360}


4363/*
* Perform a basic check on `dtype`, `sig`, and `signature` since only one
* may be set.  If `sig` is used, writes it into `out_signature` (which should
* be set to `signature_obj` so that following code only requires to handle
* `signature_obj`).
*
* Does NOT incref the output!  This only copies the borrowed references
* gotten during the argument parsing.
*
* This function does not do any normalization of the input dtype tuples,
* this happens after the array-ufunc override check currently.
*/
4375static int
4376_check_and_copy_sig_to_signature(
      PyObject *sig_obj, PyObject *signature_obj, PyObject *dtype,
      PyObject **out_signature)
4379{
  *out_signature = NULL((void*)0);
  if (signature_obj != NULL((void*)0)) {
      *out_signature = signature_obj;
  }

  if (sig_obj != NULL((void*)0)) {
      if (*out_signature != NULL((void*)0)) {
          PyErr_SetString(PyExc_TypeError,
                  "cannot specify both 'sig' and 'signature'");
          *out_signature = NULL((void*)0);
          return -1;
      }
      *out_signature = sig_obj;
  }

  if (dtype != NULL((void*)0)) {
      if (*out_signature != NULL((void*)0)) {
          PyErr_SetString(PyExc_TypeError,
                  "cannot specify both 'signature' and 'dtype'");
          return -1;
      }
      /* dtype needs to be converted, delay after the override check */
  }
  return 0;
4404}


4407/*
* Note: This function currently lets DType classes pass, but in general
* the class (not the descriptor instance) is the preferred input, so the
* parsing should eventually be adapted to prefer classes and possible
* deprecated instances. (Users should not notice that much, since `np.float64`
* or "float64" usually denotes the DType class rather than the instance.)
*/
4414static PyArray_DTypeMeta *
4415_get_dtype(PyObject *dtype_obj) {
  if (PyObject_TypeCheck(dtype_obj, &PyArrayDTypeMeta_Type)((((PyObject*)(dtype_obj))->ob_type) == (&PyArrayDTypeMeta_Type
) || PyType_IsSubtype((((PyObject*)(dtype_obj))->ob_type),
 (&PyArrayDTypeMeta_Type)))) {
      Py_INCREF(dtype_obj)_Py_INCREF(((PyObject*)(dtype_obj)));
      return (PyArray_DTypeMeta *)dtype_obj;
  }
  else {
      PyArray_Descr *descr = NULL((void*)0);
      if (!PyArray_DescrConverter(dtype_obj, &descr)) {
          return NULL((void*)0);
      }
      PyArray_DTypeMeta *out = NPY_DTYPE(descr)((PyArray_DTypeMeta *)(((PyObject*)(descr))->ob_type));
      if (NPY_UNLIKELY(!out->legacy)__builtin_expect(!!(!out->legacy), 0)) {
          /* TODO: this path was unreachable when added. */
          PyErr_SetString(PyExc_TypeError,
                  "Cannot pass a new user DType instance to the `dtype` or "
                  "`signature` arguments of ufuncs. Pass the DType class "
                  "instead.");
          Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
          return NULL((void*)0);
      }
      else if (NPY_UNLIKELY(out->singleton != descr)__builtin_expect(!!(out->singleton != descr), 0)) {
          /* This does not warn about `metadata`, but units is important. */
          if (!PyArray_EquivTypes(out->singleton, descr)) {
              PyErr_Format(PyExc_TypeError,
                      "The `dtype` and `signature` arguments to "
                      "ufuncs only select the general DType and not details "
                      "such as the byte order or time unit (with rare "
                      "exceptions see release notes).  To avoid this warning "
                      "please use the scalar types `np.float64`, or string "
                      "notation.\n"
                      "In rare cases where the time unit was preserved, "
                      "either cast the inputs or provide an output array. "
                      "In the future NumPy may transition to allow providing "
                      "`dtype=` to denote the outputs `dtype` as well");
              Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
              return NULL((void*)0);
          }
      }
      Py_INCREF(out)_Py_INCREF(((PyObject*)(out)));
      Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
      return out;
  }
4457}


4460static int
4461_make_new_typetup(
      int nop, PyArray_DTypeMeta *signature[], PyObject **out_typetup) {
  *out_typetup = PyTuple_New(nop);
  if (*out_typetup == NULL((void*)0)) {
      return -1;
  }

  int noncount = 0;
  for (int i = 0; i < nop; i++) {
      PyObject *item;
      if (signature[i] == NULL((void*)0)) {
          item = Py_None(&_Py_NoneStruct);
          noncount++;
      }
      else {
          if (!signature[i]->legacy || signature[i]->abstract) {
              /*
               * The legacy type resolution can't deal with these.
               * This path will return `None` or so in the future to
               * set an error later if the legacy type resolution is used.
               */
              PyErr_SetString(PyExc_RuntimeError,
                      "Internal NumPy error: new DType in signature not yet "
                      "supported. (This should be unreachable code!)");
              Py_SETREF(*out_typetup, NULL)do { PyObject *_py_tmp = ((PyObject*)(*out_typetup)); (*out_typetup
) = (((void*)0)); _Py_DECREF(((PyObject*)(_py_tmp))); } while
 (0);
              return -1;
          }
          item = (PyObject *)signature[i]->singleton;
      }
      Py_INCREF(item)_Py_INCREF(((PyObject*)(item)));
      PyTuple_SET_ITEM(*out_typetup, i, item)PyTuple_SetItem(*out_typetup, i, item);
  }
  if (noncount == nop) {
      /* The whole signature was None, simply ignore type tuple */
      Py_DECREF(*out_typetup)_Py_DECREF(((PyObject*)(*out_typetup)));
      *out_typetup = NULL((void*)0);
  }
  return 0;
4499}


4502/*
* Finish conversion parsing of the type tuple.  NumPy always only honored
* the type number for passed in descriptors/dtypes.
* The `dtype` argument is interpreted as the first output DType (not
* descriptor).
* Unlike the dtype of an `out` array, it influences loop selection!
*
* NOTE: This function replaces the type tuple if passed in (it steals
*       the original reference and returns a new object and reference)!
*       The caller must XDECREF the type tuple both on error or success.
*
* The function returns a new, normalized type-tuple.
*/
4515static int
4516_get_normalized_typetup(PyUFuncObject *ufunc,
      PyObject *dtype_obj, PyObject *signature_obj, PyObject **out_typetup)
4518{
  if (dtype_obj == NULL((void*)0) && signature_obj == NULL((void*)0)) {
      return 0;
  }

  int res = -1;
  int nin = ufunc->nin, nout = ufunc->nout, nop = nin + nout;
  /*
   * TODO: `signature` will be the main result in the future and
   *       not the typetup. (Type tuple construction can be deffered to when
   *       the legacy fallback is used).
   */
  PyArray_DTypeMeta *signature[NPY_MAXARGS32];
  memset(signature, '\0', sizeof(*signature) * nop);

  if (dtype_obj != NULL((void*)0)) {
      if (dtype_obj == Py_None(&_Py_NoneStruct)) {
          /* If `dtype=None` is passed, no need to do anything */
          assert(*out_typetup == NULL)((void) (0));
          return 0;
      }
      if (nout == 0) {
          /* This may be allowed (NumPy does not do this)? */
          PyErr_SetString(PyExc_TypeError,
                  "Cannot provide `dtype` when a ufunc has no outputs");
          return -1;
      }
      PyArray_DTypeMeta *dtype = _get_dtype(dtype_obj);
      if (dtype == NULL((void*)0)) {
          return -1;
      }
      for (int i = nin; i < nop; i++) {
          Py_INCREF(dtype)_Py_INCREF(((PyObject*)(dtype)));
          signature[i] = dtype;
      }
      Py_DECREF(dtype)_Py_DECREF(((PyObject*)(dtype)));
      res = _make_new_typetup(nop, signature, out_typetup);
      goto finish;
  }

  assert(signature_obj != NULL)((void) (0));
  /* Fill in specified_types from the tuple or string (signature_obj) */
  if (PyTuple_Check(signature_obj)((((((PyObject*)(signature_obj))->ob_type))->tp_flags &
 ((1UL << 26))) != 0)) {
      Py_ssize_t n = PyTuple_GET_SIZE(signature_obj)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(signature_obj
))))->ob_size);
      if (n == 1 && nop != 1) {
          /*
           * Special handling, because we deprecate this path.  The path
           * probably mainly existed since the `dtype=obj` was passed through
           * as `(obj,)` and parsed later.
           */
          if (PyTuple_GET_ITEM(signature_obj, 0)((((void) (0)), (PyTupleObject *)(signature_obj))->ob_item
[0]) == Py_None(&_Py_NoneStruct)) {
              PyErr_SetString(PyExc_TypeError,
                      "a single item type tuple cannot contain None.");
              goto finish;
          }
          if (DEPRECATE("The use of a length 1 tuple for the ufunc "PyErr_WarnEx(PyExc_DeprecationWarning,"The use of a length 1 tuple for the ufunc "
 "`signature` is deprecated. Use `dtype` or  fill the" "tuple with `None`s."
,1)
                        "`signature` is deprecated. Use `dtype` or  fill the"PyErr_WarnEx(PyExc_DeprecationWarning,"The use of a length 1 tuple for the ufunc "
 "`signature` is deprecated. Use `dtype` or  fill the" "tuple with `None`s."
,1)
                        "tuple with `None`s.")PyErr_WarnEx(PyExc_DeprecationWarning,"The use of a length 1 tuple for the ufunc "
 "`signature` is deprecated. Use `dtype` or  fill the" "tuple with `None`s."
,1) < 0) {
              goto finish;
          }
          /* Use the same logic as for `dtype=` */
          res = _get_normalized_typetup(ufunc,
                  PyTuple_GET_ITEM(signature_obj, 0)((((void) (0)), (PyTupleObject *)(signature_obj))->ob_item
[0]), NULL((void*)0), out_typetup);
          goto finish;
      }
      if (n != nop) {
          PyErr_Format(PyExc_ValueError,
                  "a type-tuple must be specified of length %d for ufunc '%s'",
                  nop, ufunc_get_name_cstr(ufunc));
          goto finish;
      }
      for (int i = 0; i < nop; ++i) {
          PyObject *item = PyTuple_GET_ITEM(signature_obj, i)((((void) (0)), (PyTupleObject *)(signature_obj))->ob_item
[i]);
          if (item == Py_None(&_Py_NoneStruct)) {
              continue;
          }
          signature[i] = _get_dtype(item);
          if (signature[i] == NULL((void*)0)) {
              goto finish;
          }
      }
  }
  else if (PyBytes_Check(signature_obj)((((((PyObject*)(signature_obj))->ob_type))->tp_flags &
 ((1UL << 27))) != 0) || PyUnicode_Check(signature_obj)((((((PyObject*)(signature_obj))->ob_type))->tp_flags &
 ((1UL << 28))) != 0)) {
      PyObject *str_object = NULL((void*)0);

      if (PyBytes_Check(signature_obj)((((((PyObject*)(signature_obj))->ob_type))->tp_flags &
 ((1UL << 27))) != 0)) {
          str_object = PyUnicode_FromEncodedObject(signature_obj, NULL((void*)0), NULL((void*)0));
          if (str_object == NULL((void*)0)) {
              goto finish;
          }
      }
      else {
          Py_INCREF(signature_obj)_Py_INCREF(((PyObject*)(signature_obj)));
          str_object = signature_obj;
      }

      Py_ssize_t length;
      const char *str = PyUnicode_AsUTF8AndSize(str_object, &length);
      if (str == NULL((void*)0)) {
          Py_DECREF(str_object)_Py_DECREF(((PyObject*)(str_object)));
          goto finish;
      }

      if (length != 1 && (length != nin+nout + 2 ||
                          str[nin] != '-' || str[nin+1] != '>')) {
          PyErr_Format(PyExc_ValueError,
                  "a type-string for %s, %d typecode(s) before and %d after "
                  "the -> sign", ufunc_get_name_cstr(ufunc), nin, nout);
          Py_DECREF(str_object)_Py_DECREF(((PyObject*)(str_object)));
          goto finish;
      }
      if (length == 1 && nin+nout != 1) {
          Py_DECREF(str_object)_Py_DECREF(((PyObject*)(str_object)));
          if (DEPRECATE("The use of a length 1 string for the ufunc "PyErr_WarnEx(PyExc_DeprecationWarning,"The use of a length 1 string for the ufunc "
 "`signature` is deprecated. Use `dtype` attribute or " "pass a tuple with `None`s."
,1)
                        "`signature` is deprecated. Use `dtype` attribute or "PyErr_WarnEx(PyExc_DeprecationWarning,"The use of a length 1 string for the ufunc "
 "`signature` is deprecated. Use `dtype` attribute or " "pass a tuple with `None`s."
,1)
                        "pass a tuple with `None`s.")PyErr_WarnEx(PyExc_DeprecationWarning,"The use of a length 1 string for the ufunc "
 "`signature` is deprecated. Use `dtype` attribute or " "pass a tuple with `None`s."
,1) < 0) {
              goto finish;
          }
          /* `signature="l"` is the same as `dtype="l"` */
          res = _get_normalized_typetup(ufunc, str_object, NULL((void*)0), out_typetup);
          goto finish;
      }
      else {
          for (int i = 0; i < nin+nout; ++i) {
              npy_intp istr = i < nin ? i : i+2;
              PyArray_Descr *descr = PyArray_DescrFromType(str[istr]);
              if (descr == NULL((void*)0)) {
                  Py_DECREF(str_object)_Py_DECREF(((PyObject*)(str_object)));
                  goto finish;
              }
              signature[i] = NPY_DTYPE(descr)((PyArray_DTypeMeta *)(((PyObject*)(descr))->ob_type));
              Py_INCREF(signature[i])_Py_INCREF(((PyObject*)(signature[i])));
              Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
          }
          Py_DECREF(str_object)_Py_DECREF(((PyObject*)(str_object)));
      }
  }
  else {
      PyErr_SetString(PyExc_TypeError,
              "the signature object to ufunc must be a string or a tuple.");
      goto finish;
  }
  res = _make_new_typetup(nop, signature, out_typetup);

finish:
  for (int i =0; i < nop; i++) {
      Py_XDECREF(signature[i])_Py_XDECREF(((PyObject*)(signature[i])));
  }
  return res;
4667}


4670/*
* Main ufunc call implementation.
*
* This implementation makes use of the "fastcall" way of passing keyword
* arguments and is called directly from `ufunc_generic_vectorcall` when
* Python has `tp_vectorcall` (Python 3.8+).
* If `tp_vectorcall` is not available, the dictionary `kwargs` are unpacked in
* `ufunc_generic_call` with fairly little overhead.
*/
4679static PyObject *
4680ufunc_generic_fastcall(PyUFuncObject *ufunc,
      PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames,
      npy_bool outer)
4683{
  PyArrayObject *operands[NPY_MAXARGS32] = {NULL((void*)0)};
  PyObject *retobj[NPY_MAXARGS32];
  PyObject *wraparr[NPY_MAXARGS32];
  PyObject *override = NULL((void*)0);
  ufunc_full_args full_args = {NULL((void*)0), NULL((void*)0)};
  PyObject *typetup = NULL((void*)0);

  int errval;
  int nin = ufunc->nin, nout = ufunc->nout, nop = ufunc->nargs;

  /*
   * Note that the input (and possibly output) arguments are passed in as
   * positional arguments. We extract these first and check for `out`
   * passed by keyword later.
   * Outputs and inputs are stored in `full_args.in` and `full_args.out`
   * as tuples (or NULL when no outputs are passed).
   */

  /* Check number of arguments */
  if ((len_args < nin) || (len_args > nop)) {
      PyErr_Format(PyExc_TypeError,
              "%s() takes from %d to %d positional arguments but "
              "%zd were given",
              ufunc_get_name_cstr(ufunc) , nin, nop, len_args);
      return NULL((void*)0);
  }

  /* Fetch input arguments. */
  full_args.in = PyTuple_New(ufunc->nin);
  if (full_args.in == NULL((void*)0)) {
      return NULL((void*)0);
  }
  for (int i = 0; i < ufunc->nin; i++) {
      PyObject *tmp = args[i];
      Py_INCREF(tmp)_Py_INCREF(((PyObject*)(tmp)));
      PyTuple_SET_ITEM(full_args.in, i, tmp)PyTuple_SetItem(full_args.in, i, tmp);
  }

  /*
   * If there are more arguments, they define the out args. Otherwise
   * full_args.out is NULL for now, and the `out` kwarg may still be passed.
   */
  npy_bool out_is_passed_by_position = len_args > nin;
  if (out_is_passed_by_position) {
      npy_bool all_none = NPY_TRUE1;

      full_args.out = PyTuple_New(nout);
      if (full_args.out == NULL((void*)0)) {
          goto fail;
      }
      for (int i = nin; i < nop; i++) {
          PyObject *tmp;
          if (i < (int)len_args) {
              tmp = args[i];
              if (tmp != Py_None(&_Py_NoneStruct)) {
                  all_none = NPY_FALSE0;
              }
          }
          else {
              tmp = Py_None(&_Py_NoneStruct);
          }
          Py_INCREF(tmp)_Py_INCREF(((PyObject*)(tmp)));
          PyTuple_SET_ITEM(full_args.out, i-nin, tmp)PyTuple_SetItem(full_args.out, i-nin, tmp);
      }
      if (all_none) {
          Py_SETREF(full_args.out, NULL)do { PyObject *_py_tmp = ((PyObject*)(full_args.out)); (full_args
.out) = (((void*)0)); _Py_DECREF(((PyObject*)(_py_tmp))); } while
 (0);
      }
  }
  else {
      full_args.out = NULL((void*)0);
  }

  /*
   * We have now extracted (but not converted) the input arguments.
   * To simplify overrides, extract all other arguments (as objects only)
   */
  PyObject *out_obj = NULL((void*)0), *where_obj = NULL((void*)0);
  PyObject *axes_obj = NULL((void*)0), *axis_obj = NULL((void*)0);
  PyObject *keepdims_obj = NULL((void*)0), *casting_obj = NULL((void*)0), *order_obj = NULL((void*)0);
  PyObject *subok_obj = NULL((void*)0), *signature_obj = NULL((void*)0), *sig_obj = NULL((void*)0);
  PyObject *dtype_obj = NULL((void*)0), *extobj = NULL((void*)0);

  /* Skip parsing if there are no keyword arguments, nothing left to do */
  if (kwnames != NULL((void*)0)) {
      if (!ufunc->core_enabled) {
          NPY_PREPARE_ARGPARSERstatic _NpyArgParserCache __argparse_cache = {-1};

          if (npy_parse_arguments(ufunc->name, args + len_args, 0, kwnames,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$where"
, ((void*)0), &where_obj, "$casting", ((void*)0), &casting_obj
, "$order", ((void*)0), &order_obj, "$subok", ((void*)0),
 &subok_obj, "$dtype", ((void*)0), &dtype_obj, "$signature"
, ((void*)0), &signature_obj, "$sig", ((void*)0), &sig_obj
, "$extobj", ((void*)0), &extobj, ((void*)0), ((void*)0),
 ((void*)0))
                  "$out", NULL, &out_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$where"
, ((void*)0), &where_obj, "$casting", ((void*)0), &casting_obj
, "$order", ((void*)0), &order_obj, "$subok", ((void*)0),
 &subok_obj, "$dtype", ((void*)0), &dtype_obj, "$signature"
, ((void*)0), &signature_obj, "$sig", ((void*)0), &sig_obj
, "$extobj", ((void*)0), &extobj, ((void*)0), ((void*)0),
 ((void*)0))
                  "$where", NULL, &where_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$where"
, ((void*)0), &where_obj, "$casting", ((void*)0), &casting_obj
, "$order", ((void*)0), &order_obj, "$subok", ((void*)0),
 &subok_obj, "$dtype", ((void*)0), &dtype_obj, "$signature"
, ((void*)0), &signature_obj, "$sig", ((void*)0), &sig_obj
, "$extobj", ((void*)0), &extobj, ((void*)0), ((void*)0),
 ((void*)0))
                  "$casting", NULL, &casting_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$where"
, ((void*)0), &where_obj, "$casting", ((void*)0), &casting_obj
, "$order", ((void*)0), &order_obj, "$subok", ((void*)0),
 &subok_obj, "$dtype", ((void*)0), &dtype_obj, "$signature"
, ((void*)0), &signature_obj, "$sig", ((void*)0), &sig_obj
, "$extobj", ((void*)0), &extobj, ((void*)0), ((void*)0),
 ((void*)0))
                  "$order", NULL, &order_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$where"
, ((void*)0), &where_obj, "$casting", ((void*)0), &casting_obj
, "$order", ((void*)0), &order_obj, "$subok", ((void*)0),
 &subok_obj, "$dtype", ((void*)0), &dtype_obj, "$signature"
, ((void*)0), &signature_obj, "$sig", ((void*)0), &sig_obj
, "$extobj", ((void*)0), &extobj, ((void*)0), ((void*)0),
 ((void*)0))
                  "$subok", NULL, &subok_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$where"
, ((void*)0), &where_obj, "$casting", ((void*)0), &casting_obj
, "$order", ((void*)0), &order_obj, "$subok", ((void*)0),
 &subok_obj, "$dtype", ((void*)0), &dtype_obj, "$signature"
, ((void*)0), &signature_obj, "$sig", ((void*)0), &sig_obj
, "$extobj", ((void*)0), &extobj, ((void*)0), ((void*)0),
 ((void*)0))
                  "$dtype", NULL, &dtype_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$where"
, ((void*)0), &where_obj, "$casting", ((void*)0), &casting_obj
, "$order", ((void*)0), &order_obj, "$subok", ((void*)0),
 &subok_obj, "$dtype", ((void*)0), &dtype_obj, "$signature"
, ((void*)0), &signature_obj, "$sig", ((void*)0), &sig_obj
, "$extobj", ((void*)0), &extobj, ((void*)0), ((void*)0),
 ((void*)0))
                  "$signature", NULL, &signature_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$where"
, ((void*)0), &where_obj, "$casting", ((void*)0), &casting_obj
, "$order", ((void*)0), &order_obj, "$subok", ((void*)0),
 &subok_obj, "$dtype", ((void*)0), &dtype_obj, "$signature"
, ((void*)0), &signature_obj, "$sig", ((void*)0), &sig_obj
, "$extobj", ((void*)0), &extobj, ((void*)0), ((void*)0),
 ((void*)0))
                  "$sig", NULL, &sig_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$where"
, ((void*)0), &where_obj, "$casting", ((void*)0), &casting_obj
, "$order", ((void*)0), &order_obj, "$subok", ((void*)0),
 &subok_obj, "$dtype", ((void*)0), &dtype_obj, "$signature"
, ((void*)0), &signature_obj, "$sig", ((void*)0), &sig_obj
, "$extobj", ((void*)0), &extobj, ((void*)0), ((void*)0),
 ((void*)0))
                  "$extobj", NULL, &extobj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$where"
, ((void*)0), &where_obj, "$casting", ((void*)0), &casting_obj
, "$order", ((void*)0), &order_obj, "$subok", ((void*)0),
 &subok_obj, "$dtype", ((void*)0), &dtype_obj, "$signature"
, ((void*)0), &signature_obj, "$sig", ((void*)0), &sig_obj
, "$extobj", ((void*)0), &extobj, ((void*)0), ((void*)0),
 ((void*)0))
                  NULL, NULL, NULL)_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$where"
, ((void*)0), &where_obj, "$casting", ((void*)0), &casting_obj
, "$order", ((void*)0), &order_obj, "$subok", ((void*)0),
 &subok_obj, "$dtype", ((void*)0), &dtype_obj, "$signature"
, ((void*)0), &signature_obj, "$sig", ((void*)0), &sig_obj
, "$extobj", ((void*)0), &extobj, ((void*)0), ((void*)0),
 ((void*)0)) < 0) {
              goto fail;
          }
      }
      else {
          NPY_PREPARE_ARGPARSERstatic _NpyArgParserCache __argparse_cache = {-1};

          if (npy_parse_arguments(ufunc->name, args + len_args, 0, kwnames,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  "$out", NULL, &out_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  "$axes", NULL, &axes_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  "$axis", NULL, &axis_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  "$keepdims", NULL, &keepdims_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  "$casting", NULL, &casting_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  "$order", NULL, &order_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  "$subok", NULL, &subok_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  "$dtype", NULL, &dtype_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  "$signature", NULL, &signature_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  "$sig", NULL, &sig_obj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  "$extobj", NULL, &extobj,_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0))
                  NULL, NULL, NULL)_npy_parse_arguments(ufunc->name, &__argparse_cache, args
 + len_args, 0, kwnames, "$out", ((void*)0), &out_obj, "$axes"
, ((void*)0), &axes_obj, "$axis", ((void*)0), &axis_obj
, "$keepdims", ((void*)0), &keepdims_obj, "$casting", ((void
*)0), &casting_obj, "$order", ((void*)0), &order_obj,
 "$subok", ((void*)0), &subok_obj, "$dtype", ((void*)0), &
dtype_obj, "$signature", ((void*)0), &signature_obj, "$sig"
, ((void*)0), &sig_obj, "$extobj", ((void*)0), &extobj
, ((void*)0), ((void*)0), ((void*)0)) < 0) {
              goto fail;
          }
          if (NPY_UNLIKELY((axes_obj != NULL) && (axis_obj != NULL))__builtin_expect(!!((axes_obj != ((void*)0)) && (axis_obj
 != ((void*)0))), 0)) {
              PyErr_SetString(PyExc_TypeError,
                      "cannot specify both 'axis' and 'axes'");
              goto fail;
          }
      }

      /* Handle `out` arguments passed by keyword */
      if (out_obj != NULL((void*)0)) {
          if (out_is_passed_by_position) {
              PyErr_SetString(PyExc_TypeError,
                      "cannot specify 'out' as both a "
                      "positional and keyword argument");
              goto fail;
          }
          if (_set_full_args_out(nout, out_obj, &full_args) < 0) {
              goto fail;
          }
      }
      /*
       * Only one of signature, sig, and dtype should be passed. If `sig`
       * was passed, this puts it into `signature_obj` instead (these
       * are borrowed references).
       */
      if (_check_and_copy_sig_to_signature(
              sig_obj, signature_obj, dtype_obj, &signature_obj) < 0) {
          goto fail;
      }
  }

  char *method;
  if (!outer) {
      method = "__call__";
  }
  else {
      method = "outer";
  }
  /* We now have all the information required to check for Overrides */
  errval = PyUFunc_CheckOverride(ufunc, method,
          full_args.in, full_args.out,
          args, len_args, kwnames, &override);
  if (errval) {
      goto fail;
  }
  else if (override) {
      Py_DECREF(full_args.in)_Py_DECREF(((PyObject*)(full_args.in)));
      Py_XDECREF(full_args.out)_Py_XDECREF(((PyObject*)(full_args.out)));
      return override;
  }

  if (outer) {
      /* Outer uses special preparation of inputs (expand dims) */
      PyObject *new_in = prepare_input_arguments_for_outer(full_args.in, ufunc);
      if (new_in == NULL((void*)0)) {
          goto fail;
      }
      Py_SETREF(full_args.in, new_in)do { PyObject *_py_tmp = ((PyObject*)(full_args.in)); (full_args
.in) = (new_in); _Py_DECREF(((PyObject*)(_py_tmp))); } while (
0);
  }

  /*
   * Parse the passed `dtype` or `signature` into an array containing
   * PyArray_DTypeMeta and/or None.
   */
  if (_get_normalized_typetup(ufunc, dtype_obj, signature_obj, &typetup) < 0) {
      goto fail;
  }

  NPY_ORDER order = NPY_KEEPORDER;
  NPY_CASTING casting = NPY_DEFAULT_ASSIGN_CASTING;
  npy_bool subok = NPY_TRUE1;
  int keepdims = -1;  /* We need to know if it was passed */
  PyArrayObject *wheremask = NULL((void*)0);
  if (convert_ufunc_arguments(ufunc, full_args, operands,
          order_obj, &order,
          casting_obj, &casting,
          subok_obj, &subok,
          where_obj, &wheremask,
          keepdims_obj, &keepdims) < 0) {
      goto fail;
  }

  if (!ufunc->core_enabled) {
      errval = PyUFunc_GenericFunctionInternal(ufunc, operands,
              full_args, typetup, extobj, casting, order, subok,
              wheremask);
      Py_XDECREF(wheremask)_Py_XDECREF(((PyObject*)(wheremask)));
  }
  else {
      errval = PyUFunc_GeneralizedFunctionInternal(ufunc, operands,
              full_args, typetup, extobj, casting, order, subok,
              axis_obj, axes_obj, keepdims);
  }

  if (errval < 0) {
      goto fail;
  }

  /* Free the input references */
  for (int i = 0; i < ufunc->nin; i++) {
      Py_XSETREF(operands[i], NULL)do { PyObject *_py_tmp = ((PyObject*)(operands[i])); (operands
[i]) = (((void*)0)); _Py_XDECREF(((PyObject*)(_py_tmp))); } while
 (0);
  }

  /*
   * Use __array_wrap__ on all outputs
   * if present on one of the input arguments.
   * If present for multiple inputs:
   * use __array_wrap__ of input object with largest
   * __array_priority__ (default = 0.0)
   *
   * Exception:  we should not wrap outputs for items already
   * passed in as output-arguments.  These items should either
   * be left unwrapped or wrapped by calling their own __array_wrap__
   * routine.
   *
   * For each output argument, wrap will be either
   * NULL --- call PyArray_Return() -- default if no output arguments given
   * None --- array-object passed in don't call PyArray_Return
   * method --- the __array_wrap__ method to call.
   */
  _find_array_wrap(full_args, subok, wraparr, ufunc->nin, ufunc->nout);

  /* wrap outputs */
  for (int i = 0; i < ufunc->nout; i++) {
      int j = ufunc->nin+i;
      _ufunc_context context;
      PyObject *wrapped;

      context.ufunc = ufunc;
      context.args = full_args;
      context.out_i = i;

      wrapped = _apply_array_wrap(wraparr[i], operands[j], &context);
      operands[j] = NULL((void*)0);  /* Prevent fail double-freeing this */
      if (wrapped == NULL((void*)0)) {
          for (int j = 0; j < i; j++) {
              Py_DECREF(retobj[j])_Py_DECREF(((PyObject*)(retobj[j])));
          }
          goto fail;
      }

      retobj[i] = wrapped;
  }

  Py_XDECREF(typetup)_Py_XDECREF(((PyObject*)(typetup)));
  Py_XDECREF(full_args.in)_Py_XDECREF(((PyObject*)(full_args.in)));
  Py_XDECREF(full_args.out)_Py_XDECREF(((PyObject*)(full_args.out)));
  if (ufunc->nout == 1) {
      return retobj[0];
  }
  else {
      PyTupleObject *ret;

      ret = (PyTupleObject *)PyTuple_New(ufunc->nout);
      for (int i = 0; i < ufunc->nout; i++) {
          PyTuple_SET_ITEM(ret, i, retobj[i])PyTuple_SetItem(ret, i, retobj[i]);
      }
      return (PyObject *)ret;
  }

4962fail:
  Py_XDECREF(typetup)_Py_XDECREF(((PyObject*)(typetup)));
  Py_XDECREF(full_args.in)_Py_XDECREF(((PyObject*)(full_args.in)));
  Py_XDECREF(full_args.out)_Py_XDECREF(((PyObject*)(full_args.out)));
  for (int i = 0; i < ufunc->nargs; i++) {
      Py_XDECREF(operands[i])_Py_XDECREF(((PyObject*)(operands[i])));
  }
  return NULL((void*)0);
4970}


4973/*
* TODO: The implementation below can be replaced with PyVectorcall_Call
*       when available (should be Python 3.8+).
*/
4977static PyObject *
4978ufunc_generic_call(
      PyUFuncObject *ufunc, PyObject *args, PyObject *kwds)
4980{
  Py_ssize_t len_args = PyTuple_GET_SIZE(args)(((PyVarObject*)((((void) (0)), (PyTupleObject *)(args))))->
ob_size);
  /*
   * Wrapper for tp_call to tp_fastcall, to support both on older versions
   * of Python. (and generally simplifying support of both versions in the
   * same codebase.
   */
  if (kwds == NULL((void*)0)) {
      return ufunc_generic_fastcall(ufunc,
              PySequence_Fast_ITEMS(args)(((((((PyObject*)(args))->ob_type))->tp_flags & ((1UL
 << 25))) != 0) ? ((PyListObject *)(args))->ob_item :
 ((PyTupleObject *)(args))->ob_item), len_args, NULL((void*)0), NPY_FALSE0);
  }

  PyObject *new_args[NPY_MAXARGS32];
  Py_ssize_t len_kwds = PyDict_Size(kwds);

  if (NPY_UNLIKELY(len_args + len_kwds > NPY_MAXARGS)__builtin_expect(!!(len_args + len_kwds > 32), 0)) {
      /*
       * We do not have enough scratch-space, so we have to abort;
       * In practice this error should not be seen by users.
       */
      PyErr_Format(PyExc_ValueError,
              "%s() takes from %d to %d positional arguments but "
              "%zd were given",
              ufunc_get_name_cstr(ufunc) , ufunc->nin, ufunc->nargs, len_args);
      return NULL((void*)0);
  }

  /* Copy args into the scratch space */
  for (Py_ssize_t i = 0; i < len_args; i++) {
      new_args[i] = PyTuple_GET_ITEM(args, i)((((void) (0)), (PyTupleObject *)(args))->ob_item[i]);
  }

  PyObject *kwnames = PyTuple_New(len_kwds);

  PyObject *key, *value;
  Py_ssize_t pos = 0;
  Py_ssize_t i = 0;
  while (PyDict_Next(kwds, &pos, &key, &value)) {
      Py_INCREF(key)_Py_INCREF(((PyObject*)(key)));
      PyTuple_SET_ITEM(kwnames, i, key)PyTuple_SetItem(kwnames, i, key);
      new_args[i + len_args] = value;
      i++;
  }

  PyObject *res = ufunc_generic_fastcall(ufunc,
          new_args, len_args, kwnames, NPY_FALSE0);
  Py_DECREF(kwnames)_Py_DECREF(((PyObject*)(kwnames)));
  return res;
5028}


5031#if PY_VERSION_HEX((3 << 24) | (8 << 16) | (5 << 8) | (0xF <<
 4) | (0 << 0)) >= 0x03080000
5032/*
* Implement vectorcallfunc which should be defined with Python 3.8+.
* In principle this could be backported, but the speed gain seems moderate
* since ufunc calls often do not have keyword arguments and always have
* a large overhead. The only user would potentially be cython probably.
*/
5038static PyObject *
5039ufunc_generic_vectorcall(PyObject *ufunc,
      PyObject *const *args, size_t len_args, PyObject *kwnames)
5041{
  /*
   * Unlike METH_FASTCALL, `len_args` may have a flag to signal that
   * args[-1] may be (temporarily) used. So normalize it here.
   */
  return ufunc_generic_fastcall((PyUFuncObject *)ufunc,
          args, PyVectorcall_NARGS(len_args), kwnames, NPY_FALSE0);
5048}
5049#endif  /* PY_VERSION_HEX >= 0x03080000 */


5052NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
5053ufunc_geterr(PyObject *NPY_UNUSED(dummy)(__NPY_UNUSED_TAGGEDdummy) __attribute__ ((__unused__)), PyObject *args)
5054{
  PyObject *thedict;
  PyObject *res;

  if (!PyArg_ParseTuple(args, "")) {
      return NULL((void*)0);
  }
  thedict = PyThreadState_GetDict();
  if (thedict == NULL((void*)0)) {
      thedict = PyEval_GetBuiltins();
  }
  res = PyDict_GetItemWithError(thedict, npy_um_str_pyvals_name);
  if (res == NULL((void*)0) && PyErr_Occurred()) {
      return NULL((void*)0);
  }
  else if (res != NULL((void*)0)) {
      Py_INCREF(res)_Py_INCREF(((PyObject*)(res)));
      return res;
  }
  /* Construct list of defaults */
  res = PyList_New(3);
  if (res == NULL((void*)0)) {
      return NULL((void*)0);
  }
  PyList_SET_ITEM(res, 0, PyLong_FromLong(NPY_BUFSIZE))PyList_SetItem(res, 0, PyLong_FromLong(8192));
  PyList_SET_ITEM(res, 1, PyLong_FromLong(UFUNC_ERR_DEFAULT))PyList_SetItem(res, 1, PyLong_FromLong((1 << 0) + (1 <<
 3) + (1 << 9)));
  PyList_SET_ITEM(res, 2, Py_None)PyList_SetItem(res, 2, (&_Py_NoneStruct)); Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return res;
5082}


5085NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
5086ufunc_seterr(PyObject *NPY_UNUSED(dummy)(__NPY_UNUSED_TAGGEDdummy) __attribute__ ((__unused__)), PyObject *args)
5087{
  PyObject *thedict;
  int res;
  PyObject *val;
  static char *msg = "Error object must be a list of length 3";

  if (!PyArg_ParseTuple(args, "O:seterrobj", &val)) {
      return NULL((void*)0);
  }
  if (!PyList_CheckExact(val)((((PyObject*)(val))->ob_type) == &PyList_Type) || PyList_GET_SIZE(val)(((void) (0)), (((PyVarObject*)(val))->ob_size)) != 3) {
      PyErr_SetString(PyExc_ValueError, msg);
      return NULL((void*)0);
  }
  thedict = PyThreadState_GetDict();
  if (thedict == NULL((void*)0)) {
      thedict = PyEval_GetBuiltins();
  }
  res = PyDict_SetItem(thedict, npy_um_str_pyvals_name, val);
  if (res < 0) {
      return NULL((void*)0);
  }
5108#if USE_USE_DEFAULTS1==1
  if (ufunc_update_use_defaults() < 0) {
      return NULL((void*)0);
  }
5112#endif
  Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
5114}



5118/*UFUNC_API*/
5119NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
5120PyUFunc_ReplaceLoopBySignature(PyUFuncObject *func,
                             PyUFuncGenericFunction newfunc,
                             const int *signature,
                             PyUFuncGenericFunction *oldfunc)
5124{
  int i, j;
  int res = -1;
  /* Find the location of the matching signature */
  for (i = 0; i < func->ntypes; i++) {
      for (j = 0; j < func->nargs; j++) {
          if (signature[j] != func->types[i*func->nargs+j]) {
              break;
          }
      }
      if (j < func->nargs) {
          continue;
      }
      if (oldfunc != NULL((void*)0)) {
          *oldfunc = func->functions[i];
      }
      func->functions[i] = newfunc;
      res = 0;
      break;
  }
  return res;
5145}

5147/*UFUNC_API*/
5148NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
5149PyUFunc_FromFuncAndData(PyUFuncGenericFunction *func, void **data,
                      char *types, int ntypes,
                      int nin, int nout, int identity,
                      const char *name, const char *doc, int unused)
5153{
  return PyUFunc_FromFuncAndDataAndSignature(func, data, types, ntypes,
      nin, nout, identity, name, doc, unused, NULL((void*)0));
5156}

5158/*UFUNC_API*/
5159NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
5160PyUFunc_FromFuncAndDataAndSignature(PyUFuncGenericFunction *func, void **data,
                                   char *types, int ntypes,
                                   int nin, int nout, int identity,
                                   const char *name, const char *doc,
                                   int unused, const char *signature)
5165{
  return PyUFunc_FromFuncAndDataAndSignatureAndIdentity(
      func, data, types, ntypes, nin, nout, identity, name, doc,
      unused, signature, NULL((void*)0));
5169}

5171/*UFUNC_API*/
5172NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyObject *
5173PyUFunc_FromFuncAndDataAndSignatureAndIdentity(PyUFuncGenericFunction *func, void **data,
                                   char *types, int ntypes,
                                   int nin, int nout, int identity,
                                   const char *name, const char *doc,
                                   const int unused, const char *signature,
                                   PyObject *identity_value)
5179{
  PyUFuncObject *ufunc;
  if (nin + nout > NPY_MAXARGS32) {
      PyErr_Format(PyExc_ValueError,
                   "Cannot construct a ufunc with more than %d operands "
                   "(requested number were: inputs = %d and outputs = %d)",
                   NPY_MAXARGS32, nin, nout);
      return NULL((void*)0);
  }

  ufunc = PyObject_GC_New(PyUFuncObject, &PyUFunc_Type)( (PyUFuncObject *) _PyObject_GC_New(&PyUFunc_Type) );
  /*
   * We use GC_New here for ufunc->obj, but do not use GC_Track since
   * ufunc->obj is still NULL at the end of this function.
   * See ufunc_frompyfunc where ufunc->obj is set and GC_Track is called.
   */
  if (ufunc == NULL((void*)0)) {
      return NULL((void*)0);
  }

  ufunc->nin = nin;
  ufunc->nout = nout;
  ufunc->nargs = nin+nout;
  ufunc->identity = identity;
  if (ufunc->identity == PyUFunc_IdentityValue-3) {
      Py_INCREF(identity_value)_Py_INCREF(((PyObject*)(identity_value)));
      ufunc->identity_value = identity_value;
  }
  else {
      ufunc->identity_value = NULL((void*)0);
  }

  ufunc->functions = func;
  ufunc->data = data;
  ufunc->types = types;
  ufunc->ntypes = ntypes;
  ufunc->core_signature = NULL((void*)0);
  ufunc->core_enabled = 0;
  ufunc->obj = NULL((void*)0);
  ufunc->core_num_dims = NULL((void*)0);
  ufunc->core_num_dim_ix = 0;
  ufunc->core_offsets = NULL((void*)0);
  ufunc->core_dim_ixs = NULL((void*)0);
  ufunc->core_dim_sizes = NULL((void*)0);
  ufunc->core_dim_flags = NULL((void*)0);
  ufunc->userloops = NULL((void*)0);
  ufunc->ptr = NULL((void*)0);
5226#if PY_VERSION_HEX((3 << 24) | (8 << 16) | (5 << 8) | (0xF <<
 4) | (0 << 0)) >= 0x03080000
  ufunc->vectorcall = &ufunc_generic_vectorcall;
5228#else
  ufunc->reserved2 = NULL((void*)0);
5230#endif
  ufunc->reserved1 = 0;
  ufunc->iter_flags = 0;

  /* Type resolution and inner loop selection functions */
  ufunc->type_resolver = &PyUFunc_DefaultTypeResolver;
  ufunc->legacy_inner_loop_selector = &PyUFunc_DefaultLegacyInnerLoopSelector;
  ufunc->masked_inner_loop_selector = &PyUFunc_DefaultMaskedInnerLoopSelector;

  if (name == NULL((void*)0)) {
      ufunc->name = "?";
  }
  else {
      ufunc->name = name;
  }
  ufunc->doc = doc;

  ufunc->op_flags = PyArray_mallocPyMem_RawMalloc(sizeof(npy_uint32)*ufunc->nargs);
  if (ufunc->op_flags == NULL((void*)0)) {
      Py_DECREF(ufunc)_Py_DECREF(((PyObject*)(ufunc)));
      return PyErr_NoMemory();
  }
  memset(ufunc->op_flags, 0, sizeof(npy_uint32)*ufunc->nargs);

  if (signature != NULL((void*)0)) {
      if (_parse_signature(ufunc, signature) != 0) {
          Py_DECREF(ufunc)_Py_DECREF(((PyObject*)(ufunc)));
          return NULL((void*)0);
      }
  }
  return (PyObject *)ufunc;
5261}


5264/*UFUNC_API*/
5265NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
5266PyUFunc_SetUsesArraysAsData(void **NPY_UNUSED(data)(__NPY_UNUSED_TAGGEDdata) __attribute__ ((__unused__)), size_t NPY_UNUSED(i)(__NPY_UNUSED_TAGGEDi) __attribute__ ((__unused__)))
5267{
  /* NumPy 1.21, 201-03-29 */
  PyErr_SetString(PyExc_RuntimeError,
          "PyUFunc_SetUsesArraysAsData() C-API function has been "
          "disabled.  It was initially deprecated in NumPy 1.19.");
  return -1;
5273}


5276/*
* This is the first-part of the CObject structure.
*
* I don't think this will change, but if it should, then
* this needs to be fixed.  The exposed C-API was insufficient
* because I needed to replace the pointer and it wouldn't
* let me with a destructor set (even though it works fine
* with the destructor).
*/
5285typedef struct {
  PyObject_HEADPyObject ob_base;
  void *c_obj;
5288} _simple_cobj;

5290#define _SETCPTR(cobj, val) ((_simple_cobj *)(cobj))->c_obj = (val)

5292/* return 1 if arg1 > arg2, 0 if arg1 == arg2, and -1 if arg1 < arg2 */
5293static int
5294cmp_arg_types(int *arg1, int *arg2, int n)
5295{
  for (; n > 0; n--, arg1++, arg2++) {
      if (PyArray_EquivTypenums(*arg1, *arg2)) {
          continue;
      }
      if (PyArray_CanCastSafely(*arg1, *arg2)) {
          return -1;
      }
      return 1;
  }
  return 0;
5306}

5308/*
* This frees the linked-list structure when the CObject
* is destroyed (removed from the internal dictionary)
5311*/
5312static NPY_INLINEinline void
5313_free_loop1d_list(PyUFunc_Loop1d *data)
5314{
  int i;

  while (data != NULL((void*)0)) {
      PyUFunc_Loop1d *next = data->next;
      PyArray_freePyMem_RawFree(data->arg_types);

      if (data->arg_dtypes != NULL((void*)0)) {
          for (i = 0; i < data->nargs; i++) {
              Py_DECREF(data->arg_dtypes[i])_Py_DECREF(((PyObject*)(data->arg_dtypes[i])));
          }
          PyArray_freePyMem_RawFree(data->arg_dtypes);
      }

      PyArray_freePyMem_RawFree(data);
      data = next;
  }
5331}

5333static void
5334_loop1d_list_free(PyObject *ptr)
5335{
  PyUFunc_Loop1d *data = (PyUFunc_Loop1d *)PyCapsule_GetPointer(ptr, NULL((void*)0));
  _free_loop1d_list(data);
5338}


5341/*
* This function allows the user to register a 1-d loop with an already
* created ufunc. This function is similar to RegisterLoopForType except
* that it allows a 1-d loop to be registered with PyArray_Descr objects
* instead of dtype type num values. This allows a 1-d loop to be registered
* for a structured array dtype or a custom dtype. The ufunc is called
* whenever any of it's input arguments match the user_dtype argument.
*
* ufunc      - ufunc object created from call to PyUFunc_FromFuncAndData
* user_dtype - dtype that ufunc will be registered with
* function   - 1-d loop function pointer
* arg_dtypes - array of dtype objects describing the ufunc operands
* data       - arbitrary data pointer passed in to loop function
*
* returns 0 on success, -1 for failure
*/
5357/*UFUNC_API*/
5358NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
5359PyUFunc_RegisterLoopForDescr(PyUFuncObject *ufunc,
                          PyArray_Descr *user_dtype,
                          PyUFuncGenericFunction function,
                          PyArray_Descr **arg_dtypes,
                          void *data)
5364{
  int i;
  int result = 0;
  int *arg_typenums;
  PyObject *key, *cobj;

  if (user_dtype == NULL((void*)0)) {
      PyErr_SetString(PyExc_TypeError,
          "unknown user defined struct dtype");
      return -1;
  }

  key = PyLong_FromLong((long) user_dtype->type_num);
  if (key == NULL((void*)0)) {
      return -1;
  }

  arg_typenums = PyArray_mallocPyMem_RawMalloc(ufunc->nargs * sizeof(int));
  if (arg_typenums == NULL((void*)0)) {
      PyErr_NoMemory();
      return -1;
  }
  if (arg_dtypes != NULL((void*)0)) {
      for (i = 0; i < ufunc->nargs; i++) {
          arg_typenums[i] = arg_dtypes[i]->type_num;
      }
  }
  else {
      for (i = 0; i < ufunc->nargs; i++) {
          arg_typenums[i] = user_dtype->type_num;
      }
  }

  result = PyUFunc_RegisterLoopForType(ufunc, user_dtype->type_num,
      function, arg_typenums, data);

  if (result == 0) {
      cobj = PyDict_GetItemWithError(ufunc->userloops, key);
      if (cobj == NULL((void*)0) && PyErr_Occurred()) {
          result = -1;
      }
      else if (cobj == NULL((void*)0)) {
          PyErr_SetString(PyExc_KeyError,
              "userloop for user dtype not found");
          result = -1;
      }
      else {
          int cmp = 1;
          PyUFunc_Loop1d *current = PyCapsule_GetPointer(cobj, NULL((void*)0));
          if (current == NULL((void*)0)) {
              result = -1;
              goto done;
          }
          while (current != NULL((void*)0)) {
              cmp = cmp_arg_types(current->arg_types,
                  arg_typenums, ufunc->nargs);
              if (cmp >= 0 && current->arg_dtypes == NULL((void*)0)) {
                  break;
              }
              current = current->next;
          }
          if (cmp == 0 && current != NULL((void*)0) && current->arg_dtypes == NULL((void*)0)) {
              current->arg_dtypes = PyArray_mallocPyMem_RawMalloc(ufunc->nargs *
                  sizeof(PyArray_Descr*));
              if (current->arg_dtypes == NULL((void*)0)) {
                  PyErr_NoMemory();
                  result = -1;
                  goto done;
              }
              else if (arg_dtypes != NULL((void*)0)) {
                  for (i = 0; i < ufunc->nargs; i++) {
                      current->arg_dtypes[i] = arg_dtypes[i];
                      Py_INCREF(current->arg_dtypes[i])_Py_INCREF(((PyObject*)(current->arg_dtypes[i])));
                  }
              }
              else {
                  for (i = 0; i < ufunc->nargs; i++) {
                      current->arg_dtypes[i] = user_dtype;
                      Py_INCREF(current->arg_dtypes[i])_Py_INCREF(((PyObject*)(current->arg_dtypes[i])));
                  }
              }
              current->nargs = ufunc->nargs;
          }
          else {
              PyErr_SetString(PyExc_RuntimeError,
                  "loop already registered");
              result = -1;
          }
      }
  }

5455done:
  PyArray_freePyMem_RawFree(arg_typenums);

  Py_DECREF(key)_Py_DECREF(((PyObject*)(key)));

  return result;
5461}

5463/*UFUNC_API*/
5464NPY_NO_EXPORT__attribute__((visibility("hidden"))) int
5465PyUFunc_RegisterLoopForType(PyUFuncObject *ufunc,
                          int usertype,
                          PyUFuncGenericFunction function,
                          const int *arg_types,
                          void *data)
5470{
  PyArray_Descr *descr;
  PyUFunc_Loop1d *funcdata;
  PyObject *key, *cobj;
  int i;
  int *newtypes=NULL((void*)0);

  descr=PyArray_DescrFromType(usertype);
  if ((usertype < NPY_USERDEF && usertype != NPY_VOID) || (descr==NULL((void*)0))) {
      PyErr_SetString(PyExc_TypeError, "unknown user-defined type");
      return -1;
  }
  Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));

  if (ufunc->userloops == NULL((void*)0)) {
      ufunc->userloops = PyDict_New();
  }
  key = PyLong_FromLong((long) usertype);
  if (key == NULL((void*)0)) {
      return -1;
  }
  funcdata = PyArray_mallocPyMem_RawMalloc(sizeof(PyUFunc_Loop1d));
  if (funcdata == NULL((void*)0)) {
      goto fail;
  }
  newtypes = PyArray_mallocPyMem_RawMalloc(sizeof(int)*ufunc->nargs);
  if (newtypes == NULL((void*)0)) {
      goto fail;
  }
  if (arg_types != NULL((void*)0)) {
      for (i = 0; i < ufunc->nargs; i++) {
          newtypes[i] = arg_types[i];
      }
  }
  else {
      for (i = 0; i < ufunc->nargs; i++) {
          newtypes[i] = usertype;
      }
  }

  funcdata->func = function;
  funcdata->arg_types = newtypes;
  funcdata->data = data;
  funcdata->next = NULL((void*)0);
  funcdata->arg_dtypes = NULL((void*)0);
  funcdata->nargs = 0;

  /* Get entry for this user-defined type*/
  cobj = PyDict_GetItemWithError(ufunc->userloops, key);
  if (cobj == NULL((void*)0) && PyErr_Occurred()) {
      return 0;
  }
  /* If it's not there, then make one and return. */
  else if (cobj == NULL((void*)0)) {
      cobj = PyCapsule_New((void *)funcdata, NULL((void*)0), _loop1d_list_free);
      if (cobj == NULL((void*)0)) {
          goto fail;
      }
      PyDict_SetItem(ufunc->userloops, key, cobj);
      Py_DECREF(cobj)_Py_DECREF(((PyObject*)(cobj)));
      Py_DECREF(key)_Py_DECREF(((PyObject*)(key)));
      return 0;
  }
  else {
      PyUFunc_Loop1d *current, *prev = NULL((void*)0);
      int cmp = 1;
      /*
       * There is already at least 1 loop. Place this one in
       * lexicographic order.  If the next one signature
       * is exactly like this one, then just replace.
       * Otherwise insert.
       */
      current = PyCapsule_GetPointer(cobj, NULL((void*)0));
      if (current == NULL((void*)0)) {
          goto fail;
      }
      while (current != NULL((void*)0)) {
          cmp = cmp_arg_types(current->arg_types, newtypes, ufunc->nargs);
          if (cmp >= 0) {
              break;
          }
          prev = current;
          current = current->next;
      }
      if (cmp == 0) {
          /* just replace it with new function */
          current->func = function;
          current->data = data;
          PyArray_freePyMem_RawFree(newtypes);
          PyArray_freePyMem_RawFree(funcdata);
      }
      else {
          /*
           * insert it before the current one by hacking the internals
           * of cobject to replace the function pointer --- can't use
           * CObject API because destructor is set.
           */
          funcdata->next = current;
          if (prev == NULL((void*)0)) {
              /* place this at front */
              _SETCPTR(cobj, funcdata);
          }
          else {
              prev->next = funcdata;
          }
      }
  }
  Py_DECREF(key)_Py_DECREF(((PyObject*)(key)));
  return 0;

fail:
  Py_DECREF(key)_Py_DECREF(((PyObject*)(key)));
  PyArray_freePyMem_RawFree(funcdata);
  PyArray_freePyMem_RawFree(newtypes);
  if (!PyErr_Occurred()) PyErr_NoMemory();
  return -1;
5586}

5588#undef _SETCPTR


5591static void
5592ufunc_dealloc(PyUFuncObject *ufunc)
5593{
  PyObject_GC_UnTrack((PyObject *)ufunc);
  PyArray_freePyMem_RawFree(ufunc->core_num_dims);
  PyArray_freePyMem_RawFree(ufunc->core_dim_ixs);
  PyArray_freePyMem_RawFree(ufunc->core_dim_sizes);
  PyArray_freePyMem_RawFree(ufunc->core_dim_flags);
  PyArray_freePyMem_RawFree(ufunc->core_offsets);
  PyArray_freePyMem_RawFree(ufunc->core_signature);
  PyArray_freePyMem_RawFree(ufunc->ptr);
  PyArray_freePyMem_RawFree(ufunc->op_flags);
  Py_XDECREF(ufunc->userloops)_Py_XDECREF(((PyObject*)(ufunc->userloops)));
  if (ufunc->identity == PyUFunc_IdentityValue-3) {
      Py_DECREF(ufunc->identity_value)_Py_DECREF(((PyObject*)(ufunc->identity_value)));
  }
  if (ufunc->obj != NULL((void*)0)) {
      Py_DECREF(ufunc->obj)_Py_DECREF(((PyObject*)(ufunc->obj)));
  }
  PyObject_GC_Del(ufunc);
5611}

5613static PyObject *
5614ufunc_repr(PyUFuncObject *ufunc)
5615{
  return PyUnicode_FromFormat("<ufunc '%s'>", ufunc->name);
5617}

5619static int
5620ufunc_traverse(PyUFuncObject *self, visitproc visit, void *arg)
5621{
  Py_VISIT(self->obj)do { if (self->obj) { int vret = visit(((PyObject*)(self->
obj)), arg); if (vret) return vret; } } while (0);
  if (self->identity == PyUFunc_IdentityValue-3) {
      Py_VISIT(self->identity_value)do { if (self->identity_value) { int vret = visit(((PyObject
*)(self->identity_value)), arg); if (vret) return vret; } }
 while (0);
  }
  return 0;
5627}

5629/******************************************************************************
***                          UFUNC METHODS                                 ***
*****************************************************************************/


5634/*
* op.outer(a,b) is equivalent to op(a[:,NewAxis,NewAxis,etc.],b)
* where a has b.ndim NewAxis terms appended.
*
* The result has dimensions a.ndim + b.ndim
*/
5640static PyObject *
5641ufunc_outer(PyUFuncObject *ufunc,
      PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames)
5643{
  if (ufunc->core_enabled) {
      PyErr_Format(PyExc_TypeError,
                   "method outer is not allowed in ufunc with non-trivial"\
                   " signature");
      return NULL((void*)0);
  }

  if (ufunc->nin != 2) {
      PyErr_SetString(PyExc_ValueError,
                      "outer product only supported "\
                      "for binary functions");
      return NULL((void*)0);
  }

  if (len_args != 2) {
      PyErr_SetString(PyExc_TypeError, "exactly two arguments expected");
      return NULL((void*)0);
  }

  return ufunc_generic_fastcall(ufunc, args, len_args, kwnames, NPY_TRUE1);
5664}


5667static PyObject *
5668prepare_input_arguments_for_outer(PyObject *args, PyUFuncObject *ufunc)
5669{
  PyArrayObject *ap1 = NULL((void*)0);
  PyObject *tmp;
  static PyObject *_numpy_matrix;
  npy_cache_import("numpy", "matrix", &_numpy_matrix);

  const char *matrix_deprecation_msg = (
          "%s.outer() was passed a numpy matrix as %s argument. "
          "Special handling of matrix is deprecated and will result in an "
          "error in most cases. Please convert the matrix to a NumPy "
          "array to retain the old behaviour. You can use `matrix.A` "
          "to achieve this.");

  tmp = PyTuple_GET_ITEM(args, 0)((((void) (0)), (PyTupleObject *)(args))->ob_item[0]);

  if (PyObject_IsInstance(tmp, _numpy_matrix)) {
      /* DEPRECATED 2020-05-13, NumPy 1.20 */
      if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
              matrix_deprecation_msg, ufunc->name, "first") < 0) {
          return NULL((void*)0);
      }
      ap1 = (PyArrayObject *) PyArray_FromObject(tmp, NPY_NOTYPE, 0, 0)PyArray_FromAny(tmp, PyArray_DescrFromType(NPY_NOTYPE), 0, 0,
 (0x0100 | 0x0400) | 0x0040, ((void*)0));
  }
  else {
      ap1 = (PyArrayObject *) PyArray_FROM_O(tmp)PyArray_FromAny(tmp, ((void*)0), 0, 0, 0, ((void*)0));
  }
  if (ap1 == NULL((void*)0)) {
      return NULL((void*)0);
  }

  PyArrayObject *ap2 = NULL((void*)0);
  tmp = PyTuple_GET_ITEM(args, 1)((((void) (0)), (PyTupleObject *)(args))->ob_item[1]);
  if (PyObject_IsInstance(tmp, _numpy_matrix)) {
      /* DEPRECATED 2020-05-13, NumPy 1.20 */
      if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
              matrix_deprecation_msg, ufunc->name, "second") < 0) {
          Py_DECREF(ap1)_Py_DECREF(((PyObject*)(ap1)));
          return NULL((void*)0);
      }
      ap2 = (PyArrayObject *) PyArray_FromObject(tmp, NPY_NOTYPE, 0, 0)PyArray_FromAny(tmp, PyArray_DescrFromType(NPY_NOTYPE), 0, 0,
 (0x0100 | 0x0400) | 0x0040, ((void*)0));
  }
  else {
      ap2 = (PyArrayObject *) PyArray_FROM_O(tmp)PyArray_FromAny(tmp, ((void*)0), 0, 0, 0, ((void*)0));
  }
  if (ap2 == NULL((void*)0)) {
      Py_DECREF(ap1)_Py_DECREF(((PyObject*)(ap1)));
      return NULL((void*)0);
  }
  /* Construct new shape from ap1 and ap2 and then reshape */
  PyArray_Dims newdims;
  npy_intp newshape[NPY_MAXDIMS32];
  newdims.len = PyArray_NDIM(ap1) + PyArray_NDIM(ap2);
  newdims.ptr = newshape;

  if (newdims.len > NPY_MAXDIMS32) {
      PyErr_Format(PyExc_ValueError,
              "maximum supported dimension for an ndarray is %d, but "
              "`%s.outer()` result would have %d.",
              NPY_MAXDIMS32, ufunc->name, newdims.len);
      goto fail;
  }
  if (newdims.ptr == NULL((void*)0)) {
      goto fail;
  }
  memcpy(newshape, PyArray_DIMS(ap1), PyArray_NDIM(ap1) * sizeof(npy_intp));
  for (int i = PyArray_NDIM(ap1); i < newdims.len; i++) {
      newshape[i] = 1;
  }

  PyArrayObject *ap_new;
  ap_new = (PyArrayObject *)PyArray_Newshape(ap1, &newdims, NPY_CORDER);
  if (ap_new == NULL((void*)0)) {
      goto fail;
  }
  if (PyArray_NDIM(ap_new) != newdims.len ||
         !PyArray_CompareLists(PyArray_DIMS(ap_new), newshape, newdims.len)) {
      PyErr_Format(PyExc_TypeError,
              "%s.outer() called with ndarray-subclass of type '%s' "
              "which modified its shape after a reshape. `outer()` relies "
              "on reshaping the inputs and is for example not supported for "
              "the 'np.matrix' class (the usage of matrix is generally "
              "discouraged). "
              "To work around this issue, please convert the inputs to "
              "numpy arrays.",
              ufunc->name, Py_TYPE(ap_new)(((PyObject*)(ap_new))->ob_type)->tp_name);
      Py_DECREF(ap_new)_Py_DECREF(((PyObject*)(ap_new)));
      goto fail;
  }

  Py_DECREF(ap1)_Py_DECREF(((PyObject*)(ap1)));
  return Py_BuildValue("(NN)", ap_new, ap2);

fail:
  Py_XDECREF(ap1)_Py_XDECREF(((PyObject*)(ap1)));
  Py_XDECREF(ap2)_Py_XDECREF(((PyObject*)(ap2)));
  return NULL((void*)0);
5765}


5768static PyObject *
5769ufunc_reduce(PyUFuncObject *ufunc,
      PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames)
5771{
  return PyUFunc_GenericReduction(
          ufunc, args, len_args, kwnames, UFUNC_REDUCE0);
5774}

5776static PyObject *
5777ufunc_accumulate(PyUFuncObject *ufunc,
      PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames)
5779{
  return PyUFunc_GenericReduction(
          ufunc, args, len_args, kwnames, UFUNC_ACCUMULATE1);
5782}

5784static PyObject *
5785ufunc_reduceat(PyUFuncObject *ufunc,
      PyObject *const *args, Py_ssize_t len_args, PyObject *kwnames)
5787{
  return PyUFunc_GenericReduction(
          ufunc, args, len_args, kwnames, UFUNC_REDUCEAT2);
5790}

5792/* Helper for ufunc_at, below */
5793static NPY_INLINEinline PyArrayObject *
5794new_array_op(PyArrayObject *op_array, char *data)
5795{
  npy_intp dims[1] = {1};
  PyObject *r = PyArray_NewFromDescr(&PyArray_Type, PyArray_DESCR(op_array),
                                     1, dims, NULL((void*)0), data,
                                     NPY_ARRAY_WRITEABLE0x0400, NULL((void*)0));
  return (PyArrayObject *)r;
5801}

5803/*
* Call ufunc only on selected array items and store result in first operand.
* For add ufunc, method call is equivalent to op1[idx] += op2 with no
* buffering of the first operand.
* Arguments:
* op1 - First operand to ufunc
* idx - Indices that are applied to first operand. Equivalent to op1[idx].
* op2 - Second operand to ufunc (if needed). Must be able to broadcast
*       over first operand.
*/
5813static PyObject *
5814ufunc_at(PyUFuncObject *ufunc, PyObject *args)
5815{
  PyObject *op1 = NULL((void*)0);
  PyObject *idx = NULL((void*)0);
  PyObject *op2 = NULL((void*)0);
  PyArrayObject *op1_array = NULL((void*)0);
  PyArrayObject *op2_array = NULL((void*)0);
  PyArrayMapIterObject *iter = NULL((void*)0);
  PyArrayIterObject *iter2 = NULL((void*)0);
  PyArray_Descr *dtypes[3] = {NULL((void*)0), NULL((void*)0), NULL((void*)0)};
  PyArrayObject *operands[3] = {NULL((void*)0), NULL((void*)0), NULL((void*)0)};
  PyArrayObject *array_operands[3] = {NULL((void*)0), NULL((void*)0), NULL((void*)0)};

  int needs_api = 0;

  PyUFuncGenericFunction innerloop;
  void *innerloopdata;
  npy_intp i;
  int nop;

  /* override vars */
  int errval;
  PyObject *override = NULL((void*)0);

  NpyIter *iter_buffer;
  NpyIter_IterNextFunc *iternext;
  npy_uint32 op_flags[NPY_MAXARGS32];
  int buffersize;
  int errormask = 0;
  char * err_msg = NULL((void*)0);
  NPY_BEGIN_THREADS_DEFPyThreadState *_save=((void*)0);;

  if (ufunc->nin > 2) {
      PyErr_SetString(PyExc_ValueError,
          "Only unary and binary ufuncs supported at this time");
      return NULL((void*)0);
  }

  if (ufunc->nout != 1) {
      PyErr_SetString(PyExc_ValueError,
          "Only single output ufuncs supported at this time");
      return NULL((void*)0);
  }

  if (!PyArg_ParseTuple(args, "OO|O:at", &op1, &idx, &op2)) {
      return NULL((void*)0);
  }

  if (ufunc->nin == 2 && op2 == NULL((void*)0)) {
      PyErr_SetString(PyExc_ValueError,
                      "second operand needed for ufunc");
      return NULL((void*)0);
  }
  errval = PyUFunc_CheckOverride(ufunc, "at",
          args, NULL((void*)0), NULL((void*)0), 0, NULL((void*)0), &override);

  if (errval) {
      return NULL((void*)0);
  }
  else if (override) {
      return override;
  }

  if (!PyArray_Check(op1)((((PyObject*)(op1))->ob_type) == (&PyArray_Type) || PyType_IsSubtype
((((PyObject*)(op1))->ob_type), (&PyArray_Type)))) {
      PyErr_SetString(PyExc_TypeError,
                      "first operand must be array");
      return NULL((void*)0);
  }

  op1_array = (PyArrayObject *)op1;

  /* Create second operand from number array if needed. */
  if (op2 != NULL((void*)0)) {
      op2_array = (PyArrayObject *)PyArray_FromAny(op2, NULL((void*)0),
                              0, 0, 0, NULL((void*)0));
      if (op2_array == NULL((void*)0)) {
          goto fail;
      }
  }

  /* Create map iterator */
  iter = (PyArrayMapIterObject *)PyArray_MapIterArrayCopyIfOverlap(
      op1_array, idx, 1, op2_array);
  if (iter == NULL((void*)0)) {
      goto fail;
  }
  op1_array = iter->array;  /* May be updateifcopied on overlap */

  if (op2 != NULL((void*)0)) {
      /*
       * May need to swap axes so that second operand is
       * iterated over correctly
       */
      if ((iter->subspace != NULL((void*)0)) && (iter->consec)) {
          PyArray_MapIterSwapAxes(iter, &op2_array, 0);
          if (op2_array == NULL((void*)0)) {
              goto fail;
          }
      }

      /*
       * Create array iter object for second operand that
       * "matches" the map iter object for the first operand.
       * Then we can just iterate over the first and second
       * operands at the same time and not have to worry about
       * picking the correct elements from each operand to apply
       * the ufunc to.
       */
      if ((iter2 = (PyArrayIterObject *)\
           PyArray_BroadcastToShape((PyObject *)op2_array,
                                      iter->dimensions, iter->nd))==NULL((void*)0)) {
          goto fail;
      }
  }

  /*
   * Create dtypes array for either one or two input operands.
   * The output operand is set to the first input operand
   */
  operands[0] = op1_array;
  if (op2_array != NULL((void*)0)) {
      operands[1] = op2_array;
      operands[2] = op1_array;
      nop = 3;
  }
  else {
      operands[1] = op1_array;
      operands[2] = NULL((void*)0);
      nop = 2;
  }

  if (ufunc->type_resolver(ufunc, NPY_UNSAFE_CASTING,
                          operands, NULL((void*)0), dtypes) < 0) {
      goto fail;
  }
  if (ufunc->legacy_inner_loop_selector(ufunc, dtypes,
      &innerloop, &innerloopdata, &needs_api) < 0) {
      goto fail;
  }

  Py_INCREF(PyArray_DESCR(op1_array))_Py_INCREF(((PyObject*)(PyArray_DESCR(op1_array))));
  array_operands[0] = new_array_op(op1_array, iter->dataptr);
  if (iter2 != NULL((void*)0)) {
      Py_INCREF(PyArray_DESCR(op2_array))_Py_INCREF(((PyObject*)(PyArray_DESCR(op2_array))));
      array_operands[1] = new_array_op(op2_array, PyArray_ITER_DATA(iter2)((void *)(((PyArrayIterObject *)(iter2))->dataptr)));
      Py_INCREF(PyArray_DESCR(op1_array))_Py_INCREF(((PyObject*)(PyArray_DESCR(op1_array))));
      array_operands[2] = new_array_op(op1_array, iter->dataptr);
  }
  else {
      Py_INCREF(PyArray_DESCR(op1_array))_Py_INCREF(((PyObject*)(PyArray_DESCR(op1_array))));
      array_operands[1] = new_array_op(op1_array, iter->dataptr);
      array_operands[2] = NULL((void*)0);
  }

  /* Set up the flags */
  op_flags[0] = NPY_ITER_READONLY0x00020000|
                NPY_ITER_ALIGNED0x00100000;

  if (iter2 != NULL((void*)0)) {
      op_flags[1] = NPY_ITER_READONLY0x00020000|
                    NPY_ITER_ALIGNED0x00100000;
      op_flags[2] = NPY_ITER_WRITEONLY0x00040000|
                    NPY_ITER_ALIGNED0x00100000|
                    NPY_ITER_ALLOCATE0x01000000|
                    NPY_ITER_NO_BROADCAST0x08000000|
                    NPY_ITER_NO_SUBTYPE0x02000000;
  }
  else {
      op_flags[1] = NPY_ITER_WRITEONLY0x00040000|
                    NPY_ITER_ALIGNED0x00100000|
                    NPY_ITER_ALLOCATE0x01000000|
                    NPY_ITER_NO_BROADCAST0x08000000|
                    NPY_ITER_NO_SUBTYPE0x02000000;
  }

  if (_get_bufsize_errmask(NULL((void*)0), ufunc->name, &buffersize, &errormask) < 0) {
      goto fail;
  }

  /*
   * Create NpyIter object to "iterate" over single element of each input
   * operand. This is an easy way to reuse the NpyIter logic for dealing
   * with certain cases like casting operands to correct dtype. On each
   * iteration over the MapIterArray object created above, we'll take the
   * current data pointers from that and reset this NpyIter object using
   * those data pointers, and then trigger a buffer copy. The buffer data
   * pointers from the NpyIter object will then be passed to the inner loop
   * function.
   */
  iter_buffer = NpyIter_AdvancedNew(nop, array_operands,
                      NPY_ITER_EXTERNAL_LOOP0x00000008|
                      NPY_ITER_REFS_OK0x00000020|
                      NPY_ITER_ZEROSIZE_OK0x00000040|
                      NPY_ITER_BUFFERED0x00000200|
                      NPY_ITER_GROWINNER0x00000400|
                      NPY_ITER_DELAY_BUFALLOC0x00000800,
                      NPY_KEEPORDER, NPY_UNSAFE_CASTING,
                      op_flags, dtypes,
                      -1, NULL((void*)0), NULL((void*)0), buffersize);

  if (iter_buffer == NULL((void*)0)) {
      goto fail;
  }

  needs_api = needs_api | NpyIter_IterationNeedsAPI(iter_buffer);

  iternext = NpyIter_GetIterNext(iter_buffer, NULL((void*)0));
  if (iternext == NULL((void*)0)) {
      NpyIter_Deallocate(iter_buffer);
      goto fail;
  }

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

  /*
   * Iterate over first and second operands and call ufunc
   * for each pair of inputs
   */
  i = iter->size;
  while (i > 0)
  {
      char *dataptr[3];
      char **buffer_dataptr;
      /* one element at a time, no stride required but read by innerloop */
      npy_intp count[3] = {1, 0xDEADBEEF, 0xDEADBEEF};
      npy_intp stride[3] = {0xDEADBEEF, 0xDEADBEEF, 0xDEADBEEF};

      /*
       * Set up data pointers for either one or two input operands.
       * The output data pointer points to the first operand data.
       */
      dataptr[0] = iter->dataptr;
      if (iter2 != NULL((void*)0)) {
          dataptr[1] = PyArray_ITER_DATA(iter2)((void *)(((PyArrayIterObject *)(iter2))->dataptr));
          dataptr[2] = iter->dataptr;
      }
      else {
          dataptr[1] = iter->dataptr;
          dataptr[2] = NULL((void*)0);
      }

      /* Reset NpyIter data pointers which will trigger a buffer copy */
      NpyIter_ResetBasePointers(iter_buffer, dataptr, &err_msg);
      if (err_msg) {
          break;
      }

      buffer_dataptr = NpyIter_GetDataPtrArray(iter_buffer);

      innerloop(buffer_dataptr, count, stride, innerloopdata);

      if (needs_api && PyErr_Occurred()) {
          break;
      }

      /*
       * Call to iternext triggers copy from buffer back to output array
       * after innerloop puts result in buffer.
       */
      iternext(iter_buffer);

      PyArray_MapIterNext(iter);
      if (iter2 != NULL((void*)0)) {
          PyArray_ITER_NEXT(iter2)do { ((PyArrayIterObject *)(iter2))->index++; if (((PyArrayIterObject
 *)(iter2))->nd_m1 == 0) { do { (((PyArrayIterObject *)(iter2
)))->dataptr += ((PyArrayIterObject *)(((PyArrayIterObject
 *)(iter2))))->strides[0]; (((PyArrayIterObject *)(iter2))
)->coordinates[0]++; } while (0); } else if (((PyArrayIterObject
 *)(iter2))->contiguous) ((PyArrayIterObject *)(iter2))->
dataptr += PyArray_DESCR(((PyArrayIterObject *)(iter2))->ao
)->elsize; else if (((PyArrayIterObject *)(iter2))->nd_m1
 == 1) { do { if ((((PyArrayIterObject *)(iter2)))->coordinates
[1] < (((PyArrayIterObject *)(iter2)))->dims_m1[1]) { (
((PyArrayIterObject *)(iter2)))->coordinates[1]++; (((PyArrayIterObject
 *)(iter2)))->dataptr += (((PyArrayIterObject *)(iter2)))->
strides[1]; } else { (((PyArrayIterObject *)(iter2)))->coordinates
[1] = 0; (((PyArrayIterObject *)(iter2)))->coordinates[0]++
; (((PyArrayIterObject *)(iter2)))->dataptr += (((PyArrayIterObject
 *)(iter2)))->strides[0] - (((PyArrayIterObject *)(iter2))
)->backstrides[1]; } } while (0); } else { int __npy_i; for
 (__npy_i=((PyArrayIterObject *)(iter2))->nd_m1; __npy_i >=
 0; __npy_i--) { if (((PyArrayIterObject *)(iter2))->coordinates
[__npy_i] < ((PyArrayIterObject *)(iter2))->dims_m1[__npy_i
]) { ((PyArrayIterObject *)(iter2))->coordinates[__npy_i]++
; ((PyArrayIterObject *)(iter2))->dataptr += ((PyArrayIterObject
 *)(iter2))->strides[__npy_i]; break; } else { ((PyArrayIterObject
 *)(iter2))->coordinates[__npy_i] = 0; ((PyArrayIterObject
 *)(iter2))->dataptr -= ((PyArrayIterObject *)(iter2))->
backstrides[__npy_i]; } } } } while (0);
      }

      i--;
  }

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

  if (err_msg) {
      PyErr_SetString(PyExc_ValueError, err_msg);
  }

  NpyIter_Deallocate(iter_buffer);

  Py_XDECREF(op2_array)_Py_XDECREF(((PyObject*)(op2_array)));
  Py_XDECREF(iter)_Py_XDECREF(((PyObject*)(iter)));
  Py_XDECREF(iter2)_Py_XDECREF(((PyObject*)(iter2)));
  for (i = 0; i < 3; i++) {
      Py_XDECREF(dtypes[i])_Py_XDECREF(((PyObject*)(dtypes[i])));
      Py_XDECREF(array_operands[i])_Py_XDECREF(((PyObject*)(array_operands[i])));
  }

  if (needs_api && PyErr_Occurred()) {
      return NULL((void*)0);
  }
  else {
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }

6108fail:
  /* iter_buffer has already been deallocated, don't use NpyIter_Dealloc */
  if (op1_array != (PyArrayObject*)op1) {
      PyArray_DiscardWritebackIfCopy(op1_array);
  }
  Py_XDECREF(op2_array)_Py_XDECREF(((PyObject*)(op2_array)));
  Py_XDECREF(iter)_Py_XDECREF(((PyObject*)(iter)));
  Py_XDECREF(iter2)_Py_XDECREF(((PyObject*)(iter2)));
  for (i = 0; i < 3; i++) {
      Py_XDECREF(dtypes[i])_Py_XDECREF(((PyObject*)(dtypes[i])));
      Py_XDECREF(array_operands[i])_Py_XDECREF(((PyObject*)(array_operands[i])));
  }

  return NULL((void*)0);
6122}


6125static struct PyMethodDef ufunc_methods[] = {
  {"reduce",
      (PyCFunction)ufunc_reduce,
      METH_FASTCALL0x0080 | METH_KEYWORDS0x0002, NULL((void*)0) },
  {"accumulate",
      (PyCFunction)ufunc_accumulate,
      METH_FASTCALL0x0080 | METH_KEYWORDS0x0002, NULL((void*)0) },
  {"reduceat",
      (PyCFunction)ufunc_reduceat,
      METH_FASTCALL0x0080 | METH_KEYWORDS0x0002, NULL((void*)0) },
  {"outer",
      (PyCFunction)ufunc_outer,
      METH_FASTCALL0x0080 | METH_KEYWORDS0x0002, NULL((void*)0)},
  {"at",
      (PyCFunction)ufunc_at,
      METH_VARARGS0x0001, NULL((void*)0)},
  {NULL((void*)0), NULL((void*)0), 0, NULL((void*)0)}           /* sentinel */
6142};


6145/******************************************************************************
***                           UFUNC GETSET                                 ***
*****************************************************************************/


6150static char
6151_typecharfromnum(int num) {
  PyArray_Descr *descr;
  char ret;

  descr = PyArray_DescrFromType(num);
  ret = descr->type;
  Py_DECREF(descr)_Py_DECREF(((PyObject*)(descr)));
  return ret;
6159}


6162static PyObject *
6163ufunc_get_doc(PyUFuncObject *ufunc)
6164{
  static PyObject *_sig_formatter;
  PyObject *doc;

  npy_cache_import(
      "numpy.core._internal",
      "_ufunc_doc_signature_formatter",
      &_sig_formatter);

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

  /*
   * Put docstring first or FindMethod finds it... could so some
   * introspection on name and nin + nout to automate the first part
   * of it the doc string shouldn't need the calling convention
   */
  doc = PyObject_CallFunctionObjArgs(_sig_formatter,
                                     (PyObject *)ufunc, NULL((void*)0));
  if (doc == NULL((void*)0)) {
      return NULL((void*)0);
  }
  if (ufunc->doc != NULL((void*)0)) {
      Py_SETREF(doc, PyUnicode_FromFormat("%S\n\n%s", doc, ufunc->doc))do { PyObject *_py_tmp = ((PyObject*)(doc)); (doc) = (PyUnicode_FromFormat
("%S\n\n%s", doc, ufunc->doc)); _Py_DECREF(((PyObject*)(_py_tmp
))); } while (0);
  }
  return doc;
6191}


6194static PyObject *
6195ufunc_get_nin(PyUFuncObject *ufunc)
6196{
  return PyLong_FromLong(ufunc->nin);
6198}

6200static PyObject *
6201ufunc_get_nout(PyUFuncObject *ufunc)
6202{
  return PyLong_FromLong(ufunc->nout);
6204}

6206static PyObject *
6207ufunc_get_nargs(PyUFuncObject *ufunc)
6208{
  return PyLong_FromLong(ufunc->nargs);
6210}

6212static PyObject *
6213ufunc_get_ntypes(PyUFuncObject *ufunc)
6214{
  return PyLong_FromLong(ufunc->ntypes);
6216}

6218static PyObject *
6219ufunc_get_types(PyUFuncObject *ufunc)
6220{
  /* return a list with types grouped input->output */
  PyObject *list;
  PyObject *str;
  int k, j, n, nt = ufunc->ntypes;
  int ni = ufunc->nin;
  int no = ufunc->nout;
  char *t;
  list = PyList_New(nt);
  if (list == NULL((void*)0)) {
      return NULL((void*)0);
  }
  t = PyArray_mallocPyMem_RawMalloc(no+ni+2);
  n = 0;
  for (k = 0; k < nt; k++) {
      for (j = 0; j<ni; j++) {
          t[j] = _typecharfromnum(ufunc->types[n]);
          n++;
      }
      t[ni] = '-';
      t[ni+1] = '>';
      for (j = 0; j < no; j++) {
          t[ni + 2 + j] = _typecharfromnum(ufunc->types[n]);
          n++;
      }
      str = PyUnicode_FromStringAndSize(t, no + ni + 2);
      PyList_SET_ITEM(list, k, str)PyList_SetItem(list, k, str);
  }
  PyArray_freePyMem_RawFree(t);
  return list;
6250}

6252static PyObject *
6253ufunc_get_name(PyUFuncObject *ufunc)
6254{
  return PyUnicode_FromString(ufunc->name);
6256}

6258static PyObject *
6259ufunc_get_identity(PyUFuncObject *ufunc)
6260{
  npy_bool reorderable;
  return _get_identity(ufunc, &reorderable);
6263}

6265static PyObject *
6266ufunc_get_signature(PyUFuncObject *ufunc)
6267{
  if (!ufunc->core_enabled) {
      Py_RETURN_NONEreturn _Py_INCREF(((PyObject*)((&_Py_NoneStruct)))), (&
_Py_NoneStruct);
  }
  return PyUnicode_FromString(ufunc->core_signature);
6272}

6274#undef _typecharfromnum

6276/*
* Docstring is now set from python
* static char *Ufunctype__doc__ = NULL;
*/
6280static PyGetSetDef ufunc_getset[] = {
  {"__doc__",
      (getter)ufunc_get_doc,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"nin",
      (getter)ufunc_get_nin,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"nout",
      (getter)ufunc_get_nout,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"nargs",
      (getter)ufunc_get_nargs,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"ntypes",
      (getter)ufunc_get_ntypes,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"types",
      (getter)ufunc_get_types,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"__name__",
      (getter)ufunc_get_name,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"identity",
      (getter)ufunc_get_identity,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {"signature",
      (getter)ufunc_get_signature,
      NULL((void*)0), NULL((void*)0), NULL((void*)0)},
  {NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0)},  /* Sentinel */
6309};


6312/******************************************************************************
***                        UFUNC TYPE OBJECT                               ***
*****************************************************************************/

6316NPY_NO_EXPORT__attribute__((visibility("hidden"))) PyTypeObject PyUFunc_Type = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 },
  .tp_name = "numpy.ufunc",
  .tp_basicsize = sizeof(PyUFuncObject),
  .tp_dealloc = (destructor)ufunc_dealloc,
  .tp_repr = (reprfunc)ufunc_repr,
  .tp_call = (ternaryfunc)ufunc_generic_call,
  .tp_str = (reprfunc)ufunc_repr,
  .tp_flags = Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0) |
6325#if PY_VERSION_HEX((3 << 24) | (8 << 16) | (5 << 8) | (0xF <<
 4) | (0 << 0)) >= 0x03080000
      _Py_TPFLAGS_HAVE_VECTORCALL(1UL << 11) |
6327#endif
      Py_TPFLAGS_HAVE_GC(1UL << 14),
  .tp_traverse = (traverseproc)ufunc_traverse,
  .tp_methods = ufunc_methods,
  .tp_getset = ufunc_getset,
6332#if PY_VERSION_HEX((3 << 24) | (8 << 16) | (5 << 8) | (0xF <<
 4) | (0 << 0)) >= 0x03080000
  .tp_vectorcall_offset = offsetof(PyUFuncObject, vectorcall)__builtin_offsetof(PyUFuncObject, vectorcall),
6334#endif
6335};

6337/* End of code for ufunc objects */
←
/opt/pyrefcon/lib/pyrefcon/models/models/_Py_INCREF.model

void _Py_INCREF(PyObject *op) { ++op->ob_refcnt; }
←
Setting reference count to 1
→