scipy/odr/__odrpack.c

Bug Summary

File:	/tmp/pyrefcon/scipy/scipy/odr/__odrpack.c
Warning:	line 74, column 3 Calling function '_Py_INCREF' with a PyObject argument whose ownership has been released (with stolen reference)

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 __odrpack.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/scipy/csa-scan,ctu-index-name=/tmp/pyrefcon/scipy/csa-scan/externalDefMap.txt,ctu-invocation-list=/tmp/pyrefcon/scipy/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 -tune-cpu generic -debug-info-kind=limited -dwarf-version=4 -debugger-tuning=gdb -fcoverage-compilation-dir=/tmp/pyrefcon/scipy -resource-dir /opt/pyrefcon/lib/clang/13.0.0 -isystem /opt/pyrefcon/lib/pyrefcon/models/python3.8 -D NDEBUG -D _FORTIFY_SOURCE=2 -D NO_ATLAS_INFO=1 -D HAVE_CBLAS -D NPY_NO_DEPRECATED_API=NPY_1_9_API_VERSION -I scipy/odr -I /usr/local/include -I /usr/include -I /usr/lib/python3/dist-packages/numpy/core/include -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/scipy -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/scipy/csa-scan/reports -x c scipy/odr/__odrpack.c

scipy/odr/__odrpack.c

→

1/* Anti-Copyright
*
* I hereby release this code into the PUBLIC DOMAIN AS IS. There is no
* support, warranty, or guarantee. I will gladly accept comments, bug
* reports, and patches, however.
*
* Robert Kern
* kern@caltech.edu
*
*/

12#define PY_SSIZE_T_CLEAN
13#include "odrpack.h"


16void F_FUNC(dodrc,DODRC)dodrc_(void (*fcn)(F_INTint *n, F_INTint *m, F_INTint *np, F_INTint *nq, F_INTint *ldn, F_INTint *ldm,
          F_INTint *ldnp, double *beta, double *xplusd, F_INTint *ifixb, F_INTint *ifixx,
          F_INTint *ldifx, F_INTint *ideval, double *f, double *fjacb, double *fjacd,
          F_INTint *istop),
         F_INTint *n, F_INTint *m, F_INTint *np, F_INTint *nq, double *beta, double *y, F_INTint *ldy,
         double *x, F_INTint *ldx, double *we, F_INTint *ldwe, F_INTint *ld2we, double *wd,
         F_INTint *ldwd, F_INTint *ld2wd, F_INTint *ifixb, F_INTint *ifixx, F_INTint *ldifx, F_INTint *job,
         F_INTint *ndigit, double *taufac, double *sstol, double *partol,
         F_INTint *maxit, F_INTint *iprF_INT, F_INTint *lunerr, F_INTint *lunrpt, double *stpb,
         double *stpd, F_INTint *ldstpd, double *sclb, double *scld, F_INTint *ldscld,
         double *work, F_INTint *lwork, F_INTint *iwork, F_INTint *liwork, F_INTint *info);
27void F_FUNC(dwinf,DWINF)dwinf_(F_INTint *n, F_INTint *m, F_INTint *np, F_INTint *nq, F_INTint *ldwe, F_INTint *ld2we, F_INTint *isodr,
      F_INTint *delta, F_INTint *eps, F_INTint *xplus, F_INTint *fn, F_INTint *sd, F_INTint *vcv, F_INTint *rvar,
      F_INTint *wss, F_INTint *wssde, F_INTint *wssep, F_INTint *rcond, F_INTint *eta, F_INTint *olmav,
      F_INTint *tau, F_INTint *alpha, F_INTint *actrs, F_INTint *pnorm, F_INTint *rnors, F_INTint *prers,
      F_INTint *partl, F_INTint *sstol, F_INTint *taufc, F_INTint *apsma, F_INTint *betao, F_INTint *betac,
      F_INTint *betas, F_INTint *betan, F_INTint *s, F_INTint *ss, F_INTint *ssf, F_INTint *qraux, F_INTint *u,
      F_INTint *fs, F_INTint *fjacb, F_INTint *we1, F_INTint *diff, F_INTint *delts, F_INTint *deltn,
      F_INTint *t, F_INTint *tt, F_INTint *omega, F_INTint *fjacd, F_INTint *wrk1, F_INTint *wrk2,
      F_INTint *wrk3, F_INTint *wrk4, F_INTint *wrk5, F_INTint *wrk6, F_INTint *wrk7, F_INTint *lwkmn);
36void F_FUNC(dluno,DLUNO)dluno_(F_INTint *lun, char *fn, int fnlen);
37void F_FUNC(dlunc,DLUNC)dlunc_(F_INTint *lun);



41/* callback to pass to DODRC; calls the Python function in the global structure |odr_global| */
42void fcn_callback(F_INTint *n, F_INTint *m, F_INTint *np, F_INTint *nq, F_INTint *ldn, F_INTint *ldm,
                F_INTint *ldnp, double *beta, double *xplusd, F_INTint *ifixb,
                F_INTint *ifixx, F_INTint *ldfix, F_INTint *ideval, double *f,
                double *fjacb, double *fjacd, F_INTint *istop)
46{
PyObject *arg01, *arglist;
PyObject *result = NULL((void*)0);
PyArrayObject *result_array = NULL((void*)0);
PyArrayObject *pyXplusD;
void *beta_dst;

arg01 = PyTuple_New(2);

if (*m != 1)
1
Assuming the condition is false→
2
←
Taking false branch→
  {
    npy_intp dim2[2];
    dim2[0] = *m;
    dim2[1] = *n;
    pyXplusD = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 2, dim2, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    memcpy(PyArray_DATA(pyXplusD), (void *)xplusd, (*m) * (*n) * sizeof(double));
  }
else
  {
    npy_intp dim1[1];
    dim1[0] = *n;
    pyXplusD = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    memcpy(PyArray_DATA(pyXplusD), (void *)xplusd, (*n) * sizeof(double));
  }

PyTuple_SetItem(arg01, 0, odr_global.pyBeta);
Py_INCREF(odr_global.pyBeta)_Py_INCREF(((PyObject*)(odr_global.pyBeta)));
PyTuple_SetItem(arg01, 1, (PyObject *) pyXplusD);
3
←
Calling 'PyTuple_SetItem'→
5
←
Returning from 'PyTuple_SetItem'→
Py_INCREF((PyObject *) pyXplusD)_Py_INCREF(((PyObject*)((PyObject *) pyXplusD)));
6
←
Calling function '_Py_INCREF' with a PyObject argument whose ownership has been released (with stolen reference)

if (odr_global.extra_args != NULL((void*)0))
  {
    arglist = PySequence_Concat(arg01, odr_global.extra_args);
  }
else
  {
    arglist = PySequence_Tuple(arg01);        /* make a copy */
  }

Py_DECREF(arg01)_Py_DECREF(((PyObject*)(arg01)));
*istop = 0;

beta_dst = (PyArray_DATA((PyArrayObject *) odr_global.pyBeta));
if (beta != beta_dst) {
    memcpy(beta_dst, (void *)beta, (*np) * sizeof(double));
}

if ((*ideval % 10) >= 1)
  {
    /* compute f with odr_global.fcn */

    if (odr_global.fcn == NULL((void*)0))
      {
        /* we don't have a function to call */
        PYERR2(odr_error, "Function has not been initialized"){PyErr_Print(); PyErr_SetString(odr_error, "Function has not been initialized"
); goto fail;};
      }

    if ((result = PyObject_CallObject(odr_global.fcn, arglist)) == NULL((void*)0))
      {
        if (PyErr_ExceptionMatches(odr_stop))
          {
            /* stop, don't fail */
            *istop = 1;

            Py_DECREF(arglist)_Py_DECREF(((PyObject*)(arglist)));
            return;
          }
        goto fail;
      }

    if ((result_array =
         (PyArrayObject *) PyArray_ContiguousFromObject(result,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(result, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_DOUBLE), 0, 2, ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))
                                                        NPY_DOUBLE, 0,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(result, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_DOUBLE), 0, 2, ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))
                                                        2)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(result, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_DOUBLE), 0, 2, ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR2(odr_error,{PyErr_Print(); PyErr_SetString(odr_error, "Result from function call is not a proper array of floats."
); goto fail;}
               "Result from function call is not a proper array of floats."){PyErr_Print(); PyErr_SetString(odr_error, "Result from function call is not a proper array of floats."
); goto fail;};
      }

    memcpy((void *)f, PyArray_DATA(result_array), (*n) * (*nq) * sizeof(double));
    Py_DECREF(result_array)_Py_DECREF(((PyObject*)(result_array)));
  }

if (((*ideval) / 10) % 10 >= 1)
  {
    /* compute fjacb with odr_global.fjacb */

    if (odr_global.fjacb == NULL((void*)0))
      {
        /* we don't have a function to call */
        PYERR2(odr_error, "Function has not been initialized"){PyErr_Print(); PyErr_SetString(odr_error, "Function has not been initialized"
); goto fail;};
      }

    if ((result = PyObject_CallObject(odr_global.fjacb, arglist)) == NULL((void*)0))
      {
        if (PyErr_ExceptionMatches(odr_stop))
          {
            /* stop, don't fail */
            *istop = 1;

            Py_DECREF(arglist)_Py_DECREF(((PyObject*)(arglist)));
            return;
          }
        goto fail;
      }

    if ((result_array =
         (PyArrayObject *) PyArray_ContiguousFromObject(result,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(result, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_DOUBLE), 0, 3, ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))
                                                        NPY_DOUBLE, 0,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(result, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_DOUBLE), 0, 3, ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))
                                                        3)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(result, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_DOUBLE), 0, 3, ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR2(odr_error,{PyErr_Print(); PyErr_SetString(odr_error, "Result from function call is not a proper array of floats."
); goto fail;}
               "Result from function call is not a proper array of floats."){PyErr_Print(); PyErr_SetString(odr_error, "Result from function call is not a proper array of floats."
); goto fail;};
      }

    if (*nq != 1 && *np != 1)
      {
        /* result_array should be rank-3 */

        if (PyArray_NDIM(result_array) != 3)
          {
            Py_DECREF(result_array)_Py_DECREF(((PyObject*)(result_array)));
            PYERR2(odr_error, "Beta Jacobian is not rank-3"){PyErr_Print(); PyErr_SetString(odr_error, "Beta Jacobian is not rank-3"
); goto fail;};
          }
      }
    else if (*nq == 1)
      {
        /* result_array should be rank-2 */

        if (PyArray_NDIM(result_array) != 2)
          {
            Py_DECREF(result_array)_Py_DECREF(((PyObject*)(result_array)));
            PYERR2(odr_error, "Beta Jacobian is not rank-2"){PyErr_Print(); PyErr_SetString(odr_error, "Beta Jacobian is not rank-2"
); goto fail;};
          }
      }

    memcpy((void *)fjacb, PyArray_DATA(result_array),
           (*n) * (*nq) * (*np) * sizeof(double));
    Py_DECREF(result_array)_Py_DECREF(((PyObject*)(result_array)));

  }

if (((*ideval) / 100) % 10 >= 1)
  {
    /* compute fjacd with odr_global.fjacd */

    if (odr_global.fjacd == NULL((void*)0))
      {
        /* we don't have a function to call */
        PYERR2(odr_error, "fjcad has not been initialized"){PyErr_Print(); PyErr_SetString(odr_error, "fjcad has not been initialized"
); goto fail;};
      }

    if ((result = PyObject_CallObject(odr_global.fjacd, arglist)) == NULL((void*)0))
      {
        if (PyErr_ExceptionMatches(odr_stop))
          {
            /* stop, don't fail */
            *istop = 1;

            Py_DECREF(arglist)_Py_DECREF(((PyObject*)(arglist)));
            return;
          }
        goto fail;
      }

    if ((result_array =
         (PyArrayObject *) PyArray_ContiguousFromObject(result,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(result, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_DOUBLE), 0, 3, ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))
                                                        NPY_DOUBLE, 0,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(result, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_DOUBLE), 0, 3, ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))
                                                        3)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(result, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_DOUBLE), 0, 3, ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR2(odr_error,{PyErr_Print(); PyErr_SetString(odr_error, "Result from function call is not a proper array of floats."
); goto fail;}
               "Result from function call is not a proper array of floats."){PyErr_Print(); PyErr_SetString(odr_error, "Result from function call is not a proper array of floats."
); goto fail;};
      }

    if (*nq != 1 && *m != 1)
      {
        /* result_array should be rank-3 */

        if (PyArray_NDIM(result_array) != 3)
          {
            Py_DECREF(result_array)_Py_DECREF(((PyObject*)(result_array)));
            PYERR2(odr_error, "xplusd Jacobian is not rank-3"){PyErr_Print(); PyErr_SetString(odr_error, "xplusd Jacobian is not rank-3"
); goto fail;};
          }
      }
    else if (*nq == 1 && *m != 1)
      {
        /* result_array should be rank-2 */

        if (PyArray_NDIM(result_array) != 2)
          {
            Py_DECREF(result_array)_Py_DECREF(((PyObject*)(result_array)));
            PYERR2(odr_error, "xplusd Jacobian is not rank-2"){PyErr_Print(); PyErr_SetString(odr_error, "xplusd Jacobian is not rank-2"
); goto fail;};
          }
      }
    else if (*nq == 1 && *m == 1)
      {
        /* result_array should be rank-1 */

        if (PyArray_NDIM(result_array) != 1)
          {
            Py_DECREF(result_array)_Py_DECREF(((PyObject*)(result_array)));
            PYERR2(odr_error, "xplusd Jacobian is not rank-1"){PyErr_Print(); PyErr_SetString(odr_error, "xplusd Jacobian is not rank-1"
); goto fail;};
          }
      }

    memcpy((void *)fjacd, PyArray_DATA(result_array),
           (*n) * (*nq) * (*m) * sizeof(double));
    Py_DECREF(result_array)_Py_DECREF(((PyObject*)(result_array)));
  }

Py_DECREF(result)_Py_DECREF(((PyObject*)(result)));
Py_DECREF(arglist)_Py_DECREF(((PyObject*)(arglist)));
Py_DECREF(pyXplusD)_Py_DECREF(((PyObject*)(pyXplusD)));

return;

262fail:
Py_XDECREF(result)_Py_XDECREF(((PyObject*)(result)));
Py_XDECREF(arglist)_Py_XDECREF(((PyObject*)(arglist)));
Py_XDECREF(pyXplusD)_Py_XDECREF(((PyObject*)(pyXplusD)));
*istop = -1;
return;
268}


271/* generates Python output from the raw output from DODRC */
272PyObject *gen_output(F_INTint n, F_INTint m, F_INTint np, F_INTint nq, F_INTint ldwe, F_INTint ld2we,
                   PyArrayObject * beta, PyArrayObject * work,
                   PyArrayObject * iwork, F_INTint isodr, F_INTint info,
                   int full_output)
276{
PyArrayObject *sd_beta, *cov_beta;

F_INTint delta, eps, xplus, fn, sd, vcv, rvar, wss, wssde, wssep, rcond;
F_INTint eta, olmav, tau, alpha, actrs, pnorm, rnors, prers, partl, sstol;
F_INTint taufc, apsma, betao, betac, betas, betan, s, ss, ssf, qraux, u;
F_INTint fs, fjacb, we1, diff, delts, deltn, t, tt, omega, fjacd;
F_INTint wrk1, wrk2, wrk3, wrk4, wrk5, wrk6, wrk7, lwkmn;

PyObject *retobj;

npy_intp dim1[1], dim2[2];

if (info == 50005) {
    /* fatal error in fcn call; return NULL to propagate the exception */

    return NULL((void*)0);
}

lwkmn = PyArray_DIMS(work)[0];

F_FUNC(dwinf,DWINF)dwinf_(&n, &m, &np, &nq, &ldwe, &ld2we, &isodr,
      &delta, &eps, &xplus, &fn, &sd, &vcv, &rvar, &wss, &wssde,
      &wssep, &rcond, &eta, &olmav, &tau, &alpha, &actrs, &pnorm,
      &rnors, &prers, &partl, &sstol, &taufc, &apsma, &betao, &betac,
      &betas, &betan, &s, &ss, &ssf, &qraux, &u, &fs, &fjacb, &we1,
      &diff, &delts, &deltn, &t, &tt, &omega, &fjacd, &wrk1, &wrk2,
      &wrk3, &wrk4, &wrk5, &wrk6, &wrk7, &lwkmn);

/* convert FORTRAN indices to C indices */
delta--;
eps--;
xplus--;
fn--;
sd--;
vcv--;
rvar--;
wss--;
wssde--;
wssep--;
rcond--;
eta--;
olmav--;
tau--;
alpha--;
actrs--;
pnorm--;
rnors--;
prers--;
partl--;
sstol--;
taufc--;
apsma--;
betao--;
betac--;
betas--;
betan--;
s--;
ss--;
ssf--;
qraux--;
u--;
fs--;
fjacb--;
we1--;
diff--;
delts--;
deltn--;
t--;
tt--;
omega--;
fjacd--;
wrk1--;
wrk2--;
wrk3--;
wrk4--;
wrk5--;
wrk6--;
wrk7--;

dim1[0] = PyArray_DIMS(beta)[0];
sd_beta = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
dim2[0] = PyArray_DIMS(beta)[0];
dim2[1] = PyArray_DIMS(beta)[0];
cov_beta = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 2, dim2, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));

memcpy(PyArray_DATA(sd_beta), (void *)((double *)(PyArray_DATA(work)) + sd),
       np * sizeof(double));
memcpy(PyArray_DATA(cov_beta), (void *)((double *)(PyArray_DATA(work)) + vcv),
       np * np * sizeof(double));

if (!full_output)
  {
    retobj = Py_BuildValue_Py_BuildValue_SizeT("OOO", PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(beta),
                           PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(sd_beta),
                           PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(cov_beta));
    Py_DECREF((PyObject *) sd_beta)_Py_DECREF(((PyObject*)((PyObject *) sd_beta)));
    Py_DECREF((PyObject *) cov_beta)_Py_DECREF(((PyObject*)((PyObject *) cov_beta)));

    return retobj;
  }
else
  {
    PyArrayObject *deltaA, *epsA, *xplusA, *fnA;
    double res_var, sum_square, sum_square_delta, sum_square_eps;
    double inv_condnum, rel_error;
    PyObject *work_ind;

    work_ind =
      Py_BuildValue_Py_BuildValue_SizeT
        (("{s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i" ",s:" F_INT_PYFMT"i"
          ",s:" F_INT_PYFMT"i" "}"),
       "delta", delta, "eps", eps, "xplus", xplus, "fn", fn, "sd", sd, "vcv",
       vcv, "rvar", rvar, "wss", wss, "wssde", wssde, "wssep", wssep,
       "rcond", rcond, "eta", eta, "olmav", olmav, "tau", tau, "alpha",
       alpha, "actrs", actrs, "pnorm", pnorm, "rnors", rnors, "prers",
       prers, "partl", partl, "sstol", sstol, "taufc", taufc, "apsma",
       apsma, "betao", betao, "betac", betac, "betas", betas, "betan",
       betan, "s", s, "ss", ss, "ssf", ssf, "qraux", qraux, "u", u, "fs",
       fs, "fjacb", fjacb, "we1", we1, "diff", diff, "delts", delts,
       "deltn", deltn, "t", t, "tt", tt, "omega", omega, "fjacd", fjacd,
       "wrk1", wrk1, "wrk2", wrk2, "wrk3", wrk3, "wrk4", wrk4, "wrk5", wrk5,
       "wrk6", wrk6, "wrk7", wrk7);

    if (m == 1)
      {
        dim1[0] = n;
        deltaA =
          (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
        xplusA =
          (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
      }
    else
      {
        dim2[0] = m;
        dim2[1] = n;
        deltaA =
          (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 2, dim2, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
        xplusA =
          (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 2, dim2, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
      }

    if (nq == 1)
      {
        dim1[0] = n;
        epsA = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
        fnA = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
      }
    else
      {
        dim2[0] = nq;
        dim2[1] = n;
        epsA = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 2, dim2, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
        fnA = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 2, dim2, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
      }

    memcpy(PyArray_DATA(deltaA), (void *)((double *)(PyArray_DATA(work)) + delta),
           m * n * sizeof(double));
    memcpy(PyArray_DATA(epsA), (void *)((double *)(PyArray_DATA(work)) + eps),
           nq * n * sizeof(double));
    memcpy(PyArray_DATA(xplusA), (void *)((double *)(PyArray_DATA(work)) + xplus),
           m * n * sizeof(double));
    memcpy(PyArray_DATA(fnA), (void *)((double *)(PyArray_DATA(work)) + fn),
           nq * n * sizeof(double));

    res_var = *((double *)(PyArray_DATA(work)) + rvar);
    sum_square = *((double *)(PyArray_DATA(work)) + wss);
    sum_square_delta = *((double *)(PyArray_DATA(work)) + wssde);
    sum_square_eps = *((double *)(PyArray_DATA(work)) + wssep);
    inv_condnum = *((double *)(PyArray_DATA(work)) + rcond);
    rel_error = *((double *)(PyArray_DATA(work)) + eta);

    retobj =
      Py_BuildValue_Py_BuildValue_SizeT
       (("OOO{s:O,s:O,s:O,s:O,s:d,s:d,s:d,s:d,s:d,s:d,s:O,s:O,s:O,s:" F_INT_PYFMT"i" "}"),
       PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(beta), PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(sd_beta),
       PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(cov_beta), "delta", PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(deltaA), "eps",
       PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(epsA), "xplus", PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(xplusA), "y",
       PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(fnA), "res_var", res_var, "sum_square", sum_square,
       "sum_square_delta", sum_square_delta, "sum_square_eps",
       sum_square_eps, "inv_condnum", inv_condnum, "rel_error", rel_error,
       "work", PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(work), "work_ind", work_ind, "iwork",
       PyArray_Return(*(PyObject * (*)(PyArrayObject *)) PyArray_API[76])(iwork), "info", info);
    Py_DECREF((PyObject *) sd_beta)_Py_DECREF(((PyObject*)((PyObject *) sd_beta)));
    Py_DECREF((PyObject *) cov_beta)_Py_DECREF(((PyObject*)((PyObject *) cov_beta)));
    Py_DECREF((PyObject *) deltaA)_Py_DECREF(((PyObject*)((PyObject *) deltaA)));
    Py_DECREF((PyObject *) epsA)_Py_DECREF(((PyObject*)((PyObject *) epsA)));
    Py_DECREF((PyObject *) xplusA)_Py_DECREF(((PyObject*)((PyObject *) xplusA)));
    Py_DECREF((PyObject *) fnA)_Py_DECREF(((PyObject*)((PyObject *) fnA)));
    Py_DECREF((PyObject *) work_ind)_Py_DECREF(((PyObject*)((PyObject *) work_ind)));

    return retobj;
  }
480}

482PyObject *odr(PyObject * self, PyObject * args, PyObject * kwds)
483{
PyObject *fcn, *initbeta, *py, *px, *pwe = NULL((void*)0), *pwd = NULL((void*)0), *fjacb = NULL((void*)0);
PyObject *fjacd = NULL((void*)0), *pifixb = NULL((void*)0), *pifixx = NULL((void*)0);
PyObject *pstpb = NULL((void*)0), *pstpd = NULL((void*)0), *psclb = NULL((void*)0), *pscld = NULL((void*)0);
PyObject *pwork = NULL((void*)0), *piwork = NULL((void*)0), *extra_args = NULL((void*)0);
F_INTint job = 0, ndigit = 0, maxit = -1, iprint = 0;
int full_output = 0;
double taufac = 0.0, sstol = -1.0, partol = -1.0;
char *errfile = NULL((void*)0), *rptfile = NULL((void*)0);
Py_ssize_t lerrfile = 0, lrptfile = 0;
PyArrayObject *beta = NULL((void*)0), *y = NULL((void*)0), *x = NULL((void*)0), *we = NULL((void*)0), *wd = NULL((void*)0);
PyArrayObject *ifixb = NULL((void*)0), *ifixx = NULL((void*)0);
PyArrayObject *stpb = NULL((void*)0), *stpd = NULL((void*)0), *sclb = NULL((void*)0), *scld = NULL((void*)0);
PyArrayObject *work = NULL((void*)0), *iwork = NULL((void*)0);
F_INTint n, m, np, nq, ldy, ldx, ldwe, ld2we, ldwd, ld2wd, ldifx;
F_INTint lunerr = -1, lunrpt = -1, ldstpd, ldscld, lwork, liwork, info = 0;
static char *kw_list[] = { "fcn", "initbeta", "y", "x", "we", "wd", "fjacb",
  "fjacd", "extra_args", "ifixb", "ifixx", "job", "iprint", "errfile",
  "rptfile", "ndigit", "taufac", "sstol", "partol",
  "maxit", "stpb", "stpd", "sclb", "scld", "work",
  "iwork", "full_output", NULL((void*)0)
};
F_INTint isodr = 1;
PyObject *result;
npy_intp dim1[1], dim2[2], dim3[3];
F_INTint implicit;                 /* flag for implicit model */


if (kwds == NULL((void*)0))
  {
      if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, ("OOOO|OOOOOOO" F_INT_PYFMT"i" F_INT_PYFMT"i"
                                   "z#z#" F_INT_PYFMT"i" "ddd" F_INT_PYFMT"i"
                                   "OOOOOOi:odr"),
                          &fcn, &initbeta, &py, &px, &pwe, &pwd,
                          &fjacb, &fjacd, &extra_args, &pifixb, &pifixx,
                          &job, &iprint, &errfile, &lerrfile, &rptfile,
                          &lrptfile, &ndigit, &taufac, &sstol, &partol,
                          &maxit, &pstpb, &pstpd, &psclb, &pscld, &pwork,
                          &piwork, &full_output))
      {
        return NULL((void*)0);
      }
  }
else
  {
    if (!PyArg_ParseTupleAndKeywords_PyArg_ParseTupleAndKeywords_SizeT(args, kwds,
                                     ("OOOO|OOOOOOO" F_INT_PYFMT"i" "" F_INT_PYFMT"i"
                                      "z#z#" F_INT_PYFMT"i" "ddd" F_INT_PYFMT"i"
                                      "OOOOOOi:odr"),
                                     kw_list, &fcn, &initbeta, &py, &px,
                                     &pwe, &pwd, &fjacb, &fjacd,
                                     &extra_args, &pifixb, &pifixx, &job,
                                     &iprint, &errfile, &lerrfile, &rptfile,
                                     &lrptfile, &ndigit, &taufac, &sstol,
                                     &partol, &maxit, &pstpb, &pstpd,
                                     &psclb, &pscld, &pwork, &piwork,
                                     &full_output))
      {
        return NULL((void*)0);
      }
  }

/* Check the validity of all arguments */

if (!PyCallable_Check(fcn))
  {
    PYERR(PyExc_TypeError, "fcn must be callable"){PyErr_SetString(PyExc_TypeError,"fcn must be callable"); goto
 fail;};
  }
if (!PySequence_Check(initbeta))
  {
    PYERR(PyExc_TypeError, "initbeta must be a sequence"){PyErr_SetString(PyExc_TypeError,"initbeta must be a sequence"
); goto fail;};
  }
if (!PySequence_Check(py) && !PyNumber_Check(py))
  {
    PYERR(PyExc_TypeError,{PyErr_SetString(PyExc_TypeError,"y must be a sequence or integer (if model is implicit)"
); goto fail;}
          "y must be a sequence or integer (if model is implicit)"){PyErr_SetString(PyExc_TypeError,"y must be a sequence or integer (if model is implicit)"
); goto fail;};
  }
if (!PySequence_Check(px))
  {
    PYERR(PyExc_TypeError, "x must be a sequence"){PyErr_SetString(PyExc_TypeError,"x must be a sequence"); goto
 fail;};
  }
if (pwe != NULL((void*)0) && !PySequence_Check(pwe) && !PyNumber_Check(pwe))
  {
    PYERR(PyExc_TypeError, "we must be a sequence or a number"){PyErr_SetString(PyExc_TypeError,"we must be a sequence or a number"
); goto fail;};
  }
if (pwd != NULL((void*)0) && !PySequence_Check(pwd) && !PyNumber_Check(pwd))
  {
    PYERR(PyExc_TypeError, "wd must be a sequence or a number"){PyErr_SetString(PyExc_TypeError,"wd must be a sequence or a number"
); goto fail;};
  }
if (fjacb != NULL((void*)0) && !PyCallable_Check(fjacb))
  {
    PYERR(PyExc_TypeError, "fjacb must be callable"){PyErr_SetString(PyExc_TypeError,"fjacb must be callable"); goto
 fail;};
  }
if (fjacd != NULL((void*)0) && !PyCallable_Check(fjacd))
  {
    PYERR(PyExc_TypeError, "fjacd must be callable"){PyErr_SetString(PyExc_TypeError,"fjacd must be callable"); goto
 fail;};
  }
if (extra_args != NULL((void*)0) && !PySequence_Check(extra_args))
  {
    PYERR(PyExc_TypeError, "extra_args must be a sequence"){PyErr_SetString(PyExc_TypeError,"extra_args must be a sequence"
); goto fail;};
  }
if (pifixx != NULL((void*)0) && !PySequence_Check(pifixx))
  {
    PYERR(PyExc_TypeError, "ifixx must be a sequence"){PyErr_SetString(PyExc_TypeError,"ifixx must be a sequence");
 goto fail;};
  }
if (pifixb != NULL((void*)0) && !PySequence_Check(pifixb))
  {
    PYERR(PyExc_TypeError, "ifixb must be a sequence"){PyErr_SetString(PyExc_TypeError,"ifixb must be a sequence");
 goto fail;};
  }
if (pstpb != NULL((void*)0) && !PySequence_Check(pstpb))
  {
    PYERR(PyExc_TypeError, "stpb must be a sequence"){PyErr_SetString(PyExc_TypeError,"stpb must be a sequence"); goto
 fail;};
  }
if (pstpd != NULL((void*)0) && !PySequence_Check(pstpd))
  {
    PYERR(PyExc_TypeError, "stpd must be a sequence"){PyErr_SetString(PyExc_TypeError,"stpd must be a sequence"); goto
 fail;};
  }
if (psclb != NULL((void*)0) && !PySequence_Check(psclb))
  {
    PYERR(PyExc_TypeError, "sclb must be a sequence"){PyErr_SetString(PyExc_TypeError,"sclb must be a sequence"); goto
 fail;};
  }
if (pscld != NULL((void*)0) && !PySequence_Check(pscld))
  {
    PYERR(PyExc_TypeError, "scld must be a sequence"){PyErr_SetString(PyExc_TypeError,"scld must be a sequence"); goto
 fail;};
  }
if (pwork != NULL((void*)0) && !PyArray_Check(pwork)((((PyObject*)(pwork))->ob_type) == (&(*(PyTypeObject *
)PyArray_API[2])) || PyType_IsSubtype((((PyObject*)(pwork))->
ob_type), (&(*(PyTypeObject *)PyArray_API[2])))))
  {
    PYERR(PyExc_TypeError, "work must be an array"){PyErr_SetString(PyExc_TypeError,"work must be an array"); goto
 fail;};
  }
if (piwork != NULL((void*)0) && !PyArray_Check(piwork)((((PyObject*)(piwork))->ob_type) == (&(*(PyTypeObject
 *)PyArray_API[2])) || PyType_IsSubtype((((PyObject*)(piwork)
)->ob_type), (&(*(PyTypeObject *)PyArray_API[2])))))
  {
    PYERR(PyExc_TypeError, "iwork must be an array"){PyErr_SetString(PyExc_TypeError,"iwork must be an array"); goto
 fail;};
  }

/* start processing the arguments and check for errors on the way */

/* check for implicit model */

implicit = (job % 10 == 1);

if (!implicit)
  {
    if ((y =
         (PyArrayObject *) PyArray_CopyFromObject(py, NPY_DOUBLE, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(py, (*(PyArray_Descr * (*)(int
)) PyArray_API[45])(NPY_DOUBLE), 1, 2, 0x0020 | ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))
                                                  2)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(py, (*(PyArray_Descr * (*)(int
)) PyArray_API[45])(NPY_DOUBLE), 1, 2, 0x0020 | ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"y could not be made into a suitable array"
); goto fail;}
              "y could not be made into a suitable array"){PyErr_SetString(PyExc_ValueError,"y could not be made into a suitable array"
); goto fail;};
      }
    n = PyArray_DIMS(y)[PyArray_NDIM(y) - 1];     /* pick the last dimension */
    if ((x =
         (PyArrayObject *) PyArray_CopyFromObject(px, NPY_DOUBLE, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(px, (*(PyArray_Descr * (*)(int
)) PyArray_API[45])(NPY_DOUBLE), 1, 2, 0x0020 | ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))
                                                  2)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(px, (*(PyArray_Descr * (*)(int
)) PyArray_API[45])(NPY_DOUBLE), 1, 2, 0x0020 | ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"x could not be made into a suitable array"
); goto fail;}
              "x could not be made into a suitable array"){PyErr_SetString(PyExc_ValueError,"x could not be made into a suitable array"
); goto fail;};
      }
    if (n != PyArray_DIMS(x)[PyArray_NDIM(x) - 1])
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"x and y don't have matching numbers of observations"
); goto fail;}
              "x and y don't have matching numbers of observations"){PyErr_SetString(PyExc_ValueError,"x and y don't have matching numbers of observations"
); goto fail;};
      }
    if (PyArray_NDIM(y) == 1)
      {
        nq = 1;
      }
    else
      {
        nq = PyArray_DIMS(y)[0];
      }

    ldx = ldy = n;
  }
else
  {                           /* we *do* have an implicit model */
    ldy = 1;
    nq = (F_INTint)PyLong_AsLong(py);
    dim1[0] = 1;

    /* initialize y to a dummy array; never referenced */
    y = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));

    if ((x =
         (PyArrayObject *) PyArray_CopyFromObject(px, NPY_DOUBLE, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(px, (*(PyArray_Descr * (*)(int
)) PyArray_API[45])(NPY_DOUBLE), 1, 2, 0x0020 | ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))
                                                  2)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(px, (*(PyArray_Descr * (*)(int
)) PyArray_API[45])(NPY_DOUBLE), 1, 2, 0x0020 | ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"x could not be made into a suitable array"
); goto fail;}
              "x could not be made into a suitable array"){PyErr_SetString(PyExc_ValueError,"x could not be made into a suitable array"
); goto fail;};
      }

    n = PyArray_DIMS(x)[PyArray_NDIM(x) - 1];
    ldx = n;
  }

if (PyArray_NDIM(x) == 1)
  {
    m = 1;
  }
else
  {
    m = PyArray_DIMS(x)[0];
  }                           /* x, y */

if ((beta =
     (PyArrayObject *) PyArray_CopyFromObject(initbeta, NPY_DOUBLE, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(initbeta, (*(PyArray_Descr * (
*)(int)) PyArray_API[45])(NPY_DOUBLE), 1, 1, 0x0020 | ((0x0001
 | (0x0100 | 0x0400))) | 0x0040, ((void*)0))
                                              1)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(initbeta, (*(PyArray_Descr * (
*)(int)) PyArray_API[45])(NPY_DOUBLE), 1, 1, 0x0020 | ((0x0001
 | (0x0100 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
  {
    PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"initbeta could not be made into a suitable array"
); goto fail;}
          "initbeta could not be made into a suitable array"){PyErr_SetString(PyExc_ValueError,"initbeta could not be made into a suitable array"
); goto fail;};
  }
np = PyArray_DIMS(beta)[0];

if (pwe == NULL((void*)0))
  {
    ldwe = ld2we = 1;
    dim1[0] = n;
    we = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    ((double *)(PyArray_DATA(we)))[0] = -1.0;
  }
else if (PyNumber_Check(pwe) && !PyArray_Check(pwe)((((PyObject*)(pwe))->ob_type) == (&(*(PyTypeObject *)
PyArray_API[2])) || PyType_IsSubtype((((PyObject*)(pwe))->
ob_type), (&(*(PyTypeObject *)PyArray_API[2])))))
  {
    /* we is a single weight, set the first value of we to -pwe */
    PyObject *tmp;
    double val;

    tmp = PyNumber_Float(pwe);
    if (tmp == NULL((void*)0))
      PYERR(PyExc_ValueError, "could not convert we to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert we to a suitable array"
); goto fail;};
    val = PyFloat_AsDouble(tmp);
    Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));

    dim3[0] = nq;
    dim3[1] = 1;
    dim3[2] = 1;
    we = (PyArrayObject *) PyArray_SimpleNew(3, dim3, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 3, dim3, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    if (implicit)
      {
        ((double *)(PyArray_DATA(we)))[0] = val;
      }
    else
      {
        ((double *)(PyArray_DATA(we)))[0] = -val;
      }
    ldwe = ld2we = 1;
  }
else if (PySequence_Check(pwe))
  {
    /* we needs to be turned into an array */

    if ((we =
         (PyArrayObject *) PyArray_CopyFromObject(pwe, NPY_DOUBLE, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pwe, (*(PyArray_Descr * (*)(int
)) PyArray_API[45])(NPY_DOUBLE), 1, 3, 0x0020 | ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))
                                                  3)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pwe, (*(PyArray_Descr * (*)(int
)) PyArray_API[45])(NPY_DOUBLE), 1, 3, 0x0020 | ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR(PyExc_ValueError, "could not convert we to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert we to a suitable array"
); goto fail;};
      }

    if (PyArray_NDIM(we) == 1 && nq == 1)
      {

        ldwe = n;
        ld2we = 1;
      }
    else if (PyArray_NDIM(we) == 1 && PyArray_DIMS(we)[0] == nq)
      {
        /* we is a rank-1 array with diagonal weightings to be broadcast
         * to all observations */
        ldwe = 1;
        ld2we = 1;
      }
    else if (PyArray_NDIM(we) == 3 && PyArray_DIMS(we)[0] == nq
             && PyArray_DIMS(we)[1] == nq && PyArray_DIMS(we)[2] == 1)
      {
        /* we is a rank-3 array with the covariant weightings
           to be broadcast to all observations */
        ldwe = 1;
        ld2we = nq;
      }
    else if (PyArray_NDIM(we) == 2 && PyArray_DIMS(we)[0] == nq
             && PyArray_DIMS(we)[1] == nq)
      {
        /* we is a rank-2 array with the full covariant weightings
           to be broadcast to all observations */
        ldwe = 1;
        ld2we = nq;
      }

    else if (PyArray_NDIM(we) == 2 && PyArray_DIMS(we)[0] == nq
             && PyArray_DIMS(we)[1] == n)
      {
        /* we is a rank-2 array with the diagonal elements of the
           covariant weightings for each observation */
        ldwe = n;
        ld2we = 1;
      }
    else if (PyArray_NDIM(we) == 3 && PyArray_DIMS(we)[0] == nq
             && PyArray_DIMS(we)[1] == nq && PyArray_DIMS(we)[2] == n)
      {
        /* we is the full specification of the covariant weights
           for each observation */
        ldwe = n;
        ld2we = nq;
      }
    else
      {
        PYERR(PyExc_ValueError, "could not convert we to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert we to a suitable array"
); goto fail;};
      }
  }                           /* we */

if (pwd == NULL((void*)0))
  {
    ldwd = ld2wd = 1;

    dim1[0] = m;
    wd = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    ((double *)(PyArray_DATA(wd)))[0] = -1.0;
  }
else if (PyNumber_Check(pwd) && !PyArray_Check(pwd)((((PyObject*)(pwd))->ob_type) == (&(*(PyTypeObject *)
PyArray_API[2])) || PyType_IsSubtype((((PyObject*)(pwd))->
ob_type), (&(*(PyTypeObject *)PyArray_API[2])))))
  {
    /* wd is a single weight, set the first value of wd to -pwd */
    PyObject *tmp;
    double val;

    tmp = PyNumber_Float(pwd);
    if (tmp == NULL((void*)0))
      PYERR(PyExc_ValueError, "could not convert wd to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert wd to a suitable array"
); goto fail;};
    val = PyFloat_AsDouble(tmp);
    Py_DECREF(tmp)_Py_DECREF(((PyObject*)(tmp)));

    dim3[0] = 1;
    dim3[1] = 1;
    dim3[2] = m;
    wd = (PyArrayObject *) PyArray_SimpleNew(3, dim3, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 3, dim3, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    ((double *)(PyArray_DATA(wd)))[0] = -val;
    ldwd = ld2wd = 1;
  }
else if (PySequence_Check(pwd))
  {
    /* wd needs to be turned into an array */

    if ((wd =
         (PyArrayObject *) PyArray_CopyFromObject(pwd, NPY_DOUBLE, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pwd, (*(PyArray_Descr * (*)(int
)) PyArray_API[45])(NPY_DOUBLE), 1, 3, 0x0020 | ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))
                                                  3)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pwd, (*(PyArray_Descr * (*)(int
)) PyArray_API[45])(NPY_DOUBLE), 1, 3, 0x0020 | ((0x0001 | (0x0100
 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR(PyExc_ValueError, "could not convert wd to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert wd to a suitable array"
); goto fail;};
      }

    if (PyArray_NDIM(wd) == 1 && m == 1)
      {
        ldwd = n;
        ld2wd = 1;
      }
    else if (PyArray_NDIM(wd) == 1 && PyArray_DIMS(wd)[0] == m)
      {
        /* wd is a rank-1 array with diagonal weightings to be broadcast
         * to all observations */
        ldwd = 1;
        ld2wd = 1;
      }

    else if (PyArray_NDIM(wd) == 3 && PyArray_DIMS(wd)[0] == m
             && PyArray_DIMS(wd)[1] == m && PyArray_DIMS(wd)[2] == 1)
      {
        /* wd is a rank-3 array with the covariant wdightings
           to be broadcast to all observations */
        ldwd = 1;
        ld2wd = m;
      }
    else if (PyArray_NDIM(wd) == 2 && PyArray_DIMS(wd)[0] == m
             && PyArray_DIMS(wd)[1] == m)
      {
        /* wd is a rank-2 array with the full covariant weightings
           to be broadcast to all observations */
        ldwd = 1;
        ld2wd = m;
      }

    else if (PyArray_NDIM(wd) == 2 && PyArray_DIMS(wd)[0] == m
             && PyArray_DIMS(wd)[1] == n)
      {
        /* wd is a rank-2 array with the diagonal elements of the
           covariant weightings for each observation */
        ldwd = n;
        ld2wd = 1;
      }
    else if (PyArray_NDIM(wd) == 3 && PyArray_DIMS(wd)[0] == m
             && PyArray_DIMS(wd)[1] == m && PyArray_DIMS(wd)[2] == n)
      {
        /* wd is the full specification of the covariant weights
           for each observation */
        ldwd = n;
        ld2wd = m;
      }
    else
      {
        PYERR(PyExc_ValueError, "could not convert wd to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert wd to a suitable array"
); goto fail;};
      }

  }                           /* wd */


if (pifixb == NULL((void*)0))
  {
    dim1[0] = np;
    ifixb = (PyArrayObject *) PyArray_SimpleNew(1, dim1, F_INT_NPY)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_INT
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    *(F_INTint *)(PyArray_DATA(ifixb)) = -1;      /* set first element negative */
  }
else
  {
    /* pifixb is a sequence as checked before */

    if ((ifixb =
         (PyArrayObject *) PyArray_CopyFromObject(pifixb, F_INT_NPY, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pifixb, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_INT), 1, 1, 0x0020 | ((0x0001 | (
0x0100 | 0x0400))) | 0x0040, ((void*)0))
                                                  1)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pifixb, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_INT), 1, 1, 0x0020 | ((0x0001 | (
0x0100 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"could not convert ifixb to a suitable array"
); goto fail;}
              "could not convert ifixb to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert ifixb to a suitable array"
); goto fail;};
      }

    if (PyArray_DIMS(ifixb)[0] != np)
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"could not convert ifixb to a suitable array"
); goto fail;}
              "could not convert ifixb to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert ifixb to a suitable array"
); goto fail;};
      }
  }                           /* ifixb */

if (pifixx == NULL((void*)0))
  {
    dim2[0] = m;
    dim2[1] = 1;
    ifixx = (PyArrayObject *) PyArray_SimpleNew(2, dim2, F_INT_NPY)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 2, dim2, NPY_INT
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    *(F_INTint *)(PyArray_DATA(ifixx)) = -1;      /* set first element negative */
    ldifx = 1;
  }
else
  {
    /* pifixx is a sequence as checked before */

    if ((ifixx =
         (PyArrayObject *) PyArray_CopyFromObject(pifixx, F_INT_NPY, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pifixx, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_INT), 1, 2, 0x0020 | ((0x0001 | (
0x0100 | 0x0400))) | 0x0040, ((void*)0))
                                                  2)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pifixx, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_INT), 1, 2, 0x0020 | ((0x0001 | (
0x0100 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"could not convert ifixx to a suitable array"
); goto fail;}
              "could not convert ifixx to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert ifixx to a suitable array"
); goto fail;};
      }

    if (PyArray_NDIM(ifixx) == 1 && PyArray_DIMS(ifixx)[0] == m)
      {
        ldifx = 1;
      }
    else if (PyArray_NDIM(ifixx) == 1 && PyArray_DIMS(ifixx)[0] == n && m == 1)
      {
        ldifx = n;
      }
    else if (PyArray_NDIM(ifixx) == 2 && PyArray_DIMS(ifixx)[0] == m
             && PyArray_DIMS(ifixx)[1] == n)
      {
        ldifx = n;
      }
    else
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"could not convert ifixx to a suitable array"
); goto fail;}
              "could not convert ifixx to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert ifixx to a suitable array"
); goto fail;};
      }
  }                           /* ifixx */

if (errfile != NULL((void*)0))
  {
    /* call FORTRAN's OPEN to open the file with a logical unit of 18 */
    lunerr = 18;
    F_FUNC(dluno,DLUNO)dluno_(&lunerr, errfile, lerrfile);
  }

if (rptfile != NULL((void*)0))
  {
    /* call FORTRAN's OPEN to open the file with a logical unit of 19 */
    lunrpt = 19;
    F_FUNC(dluno,DLUNO)dluno_(&lunrpt, rptfile, lrptfile);
  }

if (pstpb == NULL((void*)0))
  {
    dim1[0] = np;
    stpb = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    *(double *)(PyArray_DATA(stpb)) = 0.0;
  }
else                          /* pstpb is a sequence */
  {
    if ((stpb =
         (PyArrayObject *) PyArray_CopyFromObject(pstpb, NPY_DOUBLE, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pstpb, (*(PyArray_Descr * (*)(
int)) PyArray_API[45])(NPY_DOUBLE), 1, 1, 0x0020 | ((0x0001 |
 (0x0100 | 0x0400))) | 0x0040, ((void*)0))
                                                  1)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pstpb, (*(PyArray_Descr * (*)(
int)) PyArray_API[45])(NPY_DOUBLE), 1, 1, 0x0020 | ((0x0001 |
 (0x0100 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0)
        || PyArray_DIMS(stpb)[0] != np)
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"could not convert stpb to a suitable array"
); goto fail;}
              "could not convert stpb to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert stpb to a suitable array"
); goto fail;};
      }
  }                           /* stpb */

if (pstpd == NULL((void*)0))
  {
    dim2[0] = 1;
    dim2[1] = m;
    stpd = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 2, dim2, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    *(double *)(PyArray_DATA(stpd)) = 0.0;
    ldstpd = 1;
  }
else
  {
    if ((stpd =
         (PyArrayObject *) PyArray_CopyFromObject(pstpd, NPY_DOUBLE, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pstpd, (*(PyArray_Descr * (*)(
int)) PyArray_API[45])(NPY_DOUBLE), 1, 2, 0x0020 | ((0x0001 |
 (0x0100 | 0x0400))) | 0x0040, ((void*)0))
                                                  2)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pstpd, (*(PyArray_Descr * (*)(
int)) PyArray_API[45])(NPY_DOUBLE), 1, 2, 0x0020 | ((0x0001 |
 (0x0100 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"could not convert stpb to a suitable array"
); goto fail;}
              "could not convert stpb to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert stpb to a suitable array"
); goto fail;};
      }

    if (PyArray_NDIM(stpd) == 1 && PyArray_DIMS(stpd)[0] == m)
      {
        ldstpd = 1;
      }
    else if (PyArray_NDIM(stpd) == 1 && PyArray_DIMS(stpd)[0] == n && m == 1)
      {
        ldstpd = n;
      }
    else if (PyArray_NDIM(stpd) == 2 && PyArray_DIMS(stpd)[0] == n &&
             PyArray_DIMS(stpd)[1] == m)
      {
        ldstpd = n;
      }
  }                           /* stpd */

if (psclb == NULL((void*)0))
  {
    dim1[0] = np;
    sclb = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    *(double *)(PyArray_DATA(sclb)) = 0.0;
  }
else                          /* psclb is a sequence */
  {
    if ((sclb =
         (PyArrayObject *) PyArray_CopyFromObject(psclb, NPY_DOUBLE, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(psclb, (*(PyArray_Descr * (*)(
int)) PyArray_API[45])(NPY_DOUBLE), 1, 1, 0x0020 | ((0x0001 |
 (0x0100 | 0x0400))) | 0x0040, ((void*)0))
                                                  1)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(psclb, (*(PyArray_Descr * (*)(
int)) PyArray_API[45])(NPY_DOUBLE), 1, 1, 0x0020 | ((0x0001 |
 (0x0100 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0)
        || PyArray_DIMS(sclb)[0] != np)
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"could not convert sclb to a suitable array"
); goto fail;}
              "could not convert sclb to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert sclb to a suitable array"
); goto fail;};
      }
  }                           /* sclb */

if (pscld == NULL((void*)0))
  {
    dim2[0] = 1;
    dim2[1] = n;
    scld = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 2, dim2, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
    *(double *)(PyArray_DATA(scld)) = 0.0;
    ldscld = 1;
  }
else
  {
    if ((scld =
         (PyArrayObject *) PyArray_CopyFromObject(pscld, NPY_DOUBLE, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pscld, (*(PyArray_Descr * (*)(
int)) PyArray_API[45])(NPY_DOUBLE), 1, 2, 0x0020 | ((0x0001 |
 (0x0100 | 0x0400))) | 0x0040, ((void*)0))
                                                  2)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pscld, (*(PyArray_Descr * (*)(
int)) PyArray_API[45])(NPY_DOUBLE), 1, 2, 0x0020 | ((0x0001 |
 (0x0100 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"could not convert stpb to a suitable array"
); goto fail;}
              "could not convert stpb to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert stpb to a suitable array"
); goto fail;};
      }

    if (PyArray_NDIM(scld) == 1 && PyArray_DIMS(scld)[0] == m)
      {
        ldscld = 1;
      }
    else if (PyArray_NDIM(scld) == 1 && PyArray_DIMS(scld)[0] == n && m == 1)
      {
        ldscld = n;
      }
    else if (PyArray_NDIM(scld) == 2 && PyArray_DIMS(scld)[0] == n &&
             PyArray_DIMS(scld)[1] == m)
      {
        ldscld = n;
      }
  }                           /* scld */

if (job % 10 < 2)
  {
    /* ODR, not OLS */

    lwork =
      18 + 11 * np + np * np + m + m * m + 4 * n * nq + 6 * n * m +
      2 * n * nq * np + 2 * n * nq * m + nq * nq + 5 * nq + nq * (np + m) +
      ldwe * ld2we * nq;

    isodr = 1;
  }
else
  {
    /* OLS, not ODR */

    lwork =
      18 + 11 * np + np * np + m + m * m + 4 * n * nq + 2 * n * m +
      2 * n * nq * np + 5 * nq + nq * (np + m) + ldwe * ld2we * nq;

    isodr = 0;
  }

liwork = 20 + np + nq * (np + m);

if ((job / 10000) % 10 >= 1)
  {
    /* fit is a restart, make sure work and iwork are input */

    if (pwork == NULL((void*)0) || piwork == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"need to input work and iwork arrays to restart"
); goto fail;}
              "need to input work and iwork arrays to restart"){PyErr_SetString(PyExc_ValueError,"need to input work and iwork arrays to restart"
); goto fail;};
      }
  }

if ((job / 1000) % 10 >= 1)
  {
    /* delta should be supplied, make sure the user does */

    if (pwork == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"need to input work array for delta initialization"
); goto fail;}
              "need to input work array for delta initialization"){PyErr_SetString(PyExc_ValueError,"need to input work array for delta initialization"
); goto fail;};
      }
  }

if (pwork != NULL((void*)0))
  {
    if ((work =
         (PyArrayObject *) PyArray_CopyFromObject(pwork, NPY_DOUBLE, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pwork, (*(PyArray_Descr * (*)(
int)) PyArray_API[45])(NPY_DOUBLE), 1, 1, 0x0020 | ((0x0001 |
 (0x0100 | 0x0400))) | 0x0040, ((void*)0))
                                                  1)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(pwork, (*(PyArray_Descr * (*)(
int)) PyArray_API[45])(NPY_DOUBLE), 1, 1, 0x0020 | ((0x0001 |
 (0x0100 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"could not convert work to a suitable array"
); goto fail;}
              "could not convert work to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert work to a suitable array"
); goto fail;};
      }
    if (PyArray_DIMS(work)[0] < lwork)
      {
        printf("%ld %lld\n", PyArray_DIMS(work)[0], (long long)lwork)__printf_chk (2 - 1, "%ld %lld\n", PyArray_DIMS(work)[0], (long
 long)lwork);
        PYERR(PyExc_ValueError, "work is too small"){PyErr_SetString(PyExc_ValueError,"work is too small"); goto fail
;};
      }
  }
else
  {
    /* initialize our own work array */
    dim1[0] = lwork;
    work = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_DOUBLE
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
  }                           /* work */

if (piwork != NULL((void*)0))
  {
    if ((iwork =
         (PyArrayObject *) PyArray_CopyFromObject(piwork, F_INT_NPY, 1,(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(piwork, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_INT), 1, 1, 0x0020 | ((0x0001 | (
0x0100 | 0x0400))) | 0x0040, ((void*)0))
                                                  1)(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int,
 PyObject *)) PyArray_API[69])(piwork, (*(PyArray_Descr * (*)
(int)) PyArray_API[45])(NPY_INT), 1, 1, 0x0020 | ((0x0001 | (
0x0100 | 0x0400))) | 0x0040, ((void*)0))) == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"could not convert iwork to a suitable array"
); goto fail;}
              "could not convert iwork to a suitable array"){PyErr_SetString(PyExc_ValueError,"could not convert iwork to a suitable array"
); goto fail;};
      }

    if (PyArray_DIMS(iwork)[0] < liwork)
      {
        PYERR(PyExc_ValueError, "iwork is too small"){PyErr_SetString(PyExc_ValueError,"iwork is too small"); goto
 fail;};
      }
  }
else
  {
    /* initialize our own iwork array */
    dim1[0] = liwork;
    iwork = (PyArrayObject *) PyArray_SimpleNew(1, dim1, F_INT_NPY)(*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int,
 npy_intp const *, void *, int, int, PyObject *)) PyArray_API
[93])(&(*(PyTypeObject *)PyArray_API[2]), 1, dim1, NPY_INT
, ((void*)0), ((void*)0), 0, 0, ((void*)0));
  }                           /* iwork */

/* check if what JOB requests can be done with what the user has
   input into the function */

if ((job / 10) % 10 >= 2)
  {
    /* derivatives are supposed to be supplied */

    if (fjacb == NULL((void*)0) || fjacd == NULL((void*)0))
      {
        PYERR(PyExc_ValueError,{PyErr_SetString(PyExc_ValueError,"need fjacb and fjacd to calculate derivatives"
); goto fail;}
              "need fjacb and fjacd to calculate derivatives"){PyErr_SetString(PyExc_ValueError,"need fjacb and fjacd to calculate derivatives"
); goto fail;};
      }
  }

/* setup the global data for the callback */
odr_global.fcn = fcn;
Py_INCREF(fcn)_Py_INCREF(((PyObject*)(fcn)));
odr_global.fjacb = fjacb;
Py_XINCREF(fjacb)_Py_XINCREF(((PyObject*)(fjacb)));
odr_global.fjacd = fjacd;
Py_XINCREF(fjacd)_Py_XINCREF(((PyObject*)(fjacd)));
odr_global.pyBeta = (PyObject *) beta;
Py_INCREF(beta)_Py_INCREF(((PyObject*)(beta)));
odr_global.extra_args = extra_args;
Py_XINCREF(extra_args)_Py_XINCREF(((PyObject*)(extra_args)));
 /* now call DODRC */
 F_FUNC(dodrc,DODRC)dodrc_(fcn_callback, &n, &m, &np, &nq, (double *)(PyArray_DATA(beta)),
       (double *)(PyArray_DATA(y)), &ldy, (double *)(PyArray_DATA(x)), &ldx,
       (double *)(PyArray_DATA(we)), &ldwe, &ld2we,
       (double *)(PyArray_DATA(wd)), &ldwd, &ld2wd,
       (F_INTint *)(PyArray_DATA(ifixb)), (F_INTint *)(PyArray_DATA(ifixx)), &ldifx,
       &job, &ndigit, &taufac, &sstol, &partol, &maxit,
       &iprint, &lunerr, &lunrpt,
       (double *)(PyArray_DATA(stpb)), (double *)(PyArray_DATA(stpd)), &ldstpd,
       (double *)(PyArray_DATA(sclb)), (double *)(PyArray_DATA(scld)), &ldscld,
       (double *)(PyArray_DATA(work)), &lwork, (F_INTint *)(PyArray_DATA(iwork)), &liwork,
       &info);

result = gen_output(n, m, np, nq, ldwe, ld2we,
                    beta, work, iwork, isodr, info, full_output);

if (result == NULL((void*)0))
  PYERR(PyExc_RuntimeError, "could not generate output"){PyErr_SetString(PyExc_RuntimeError,"could not generate output"
); goto fail;};

if (lunerr != -1)
  {
    F_FUNC(dlunc,DLUNC)dlunc_(&lunerr);
  }
if (lunrpt != -1)
  {
    F_FUNC(dlunc,DLUNC)dlunc_(&lunrpt);
  }

Py_DECREF(odr_global.fcn)_Py_DECREF(((PyObject*)(odr_global.fcn)));
Py_XDECREF(odr_global.fjacb)_Py_XDECREF(((PyObject*)(odr_global.fjacb)));
Py_XDECREF(odr_global.fjacd)_Py_XDECREF(((PyObject*)(odr_global.fjacd)));
Py_DECREF(odr_global.pyBeta)_Py_DECREF(((PyObject*)(odr_global.pyBeta)));
Py_XDECREF(odr_global.extra_args)_Py_XDECREF(((PyObject*)(odr_global.extra_args)));

odr_global.fcn = odr_global.fjacb = odr_global.fjacd = odr_global.pyBeta =
  odr_global.extra_args = NULL((void*)0);

Py_DECREF(beta)_Py_DECREF(((PyObject*)(beta)));
Py_DECREF(y)_Py_DECREF(((PyObject*)(y)));
Py_DECREF(x)_Py_DECREF(((PyObject*)(x)));
Py_DECREF(we)_Py_DECREF(((PyObject*)(we)));
Py_DECREF(wd)_Py_DECREF(((PyObject*)(wd)));
Py_DECREF(ifixb)_Py_DECREF(((PyObject*)(ifixb)));
Py_DECREF(ifixx)_Py_DECREF(((PyObject*)(ifixx)));
Py_DECREF(stpb)_Py_DECREF(((PyObject*)(stpb)));
Py_DECREF(stpd)_Py_DECREF(((PyObject*)(stpd)));
Py_DECREF(sclb)_Py_DECREF(((PyObject*)(sclb)));
Py_DECREF(scld)_Py_DECREF(((PyObject*)(scld)));
Py_DECREF(work)_Py_DECREF(((PyObject*)(work)));
Py_DECREF(iwork)_Py_DECREF(((PyObject*)(iwork)));

return result;

1232fail:


if (lunerr != -1)
  {
    F_FUNC(dlunc,DLUNC)dlunc_(&lunerr);
  }
if (lunrpt != -1)
  {
    F_FUNC(dlunc,DLUNC)dlunc_(&lunrpt);
  }

Py_XDECREF(beta)_Py_XDECREF(((PyObject*)(beta)));
Py_XDECREF(y)_Py_XDECREF(((PyObject*)(y)));
Py_XDECREF(x)_Py_XDECREF(((PyObject*)(x)));
Py_XDECREF(we)_Py_XDECREF(((PyObject*)(we)));
Py_XDECREF(wd)_Py_XDECREF(((PyObject*)(wd)));
Py_XDECREF(ifixb)_Py_XDECREF(((PyObject*)(ifixb)));
Py_XDECREF(ifixx)_Py_XDECREF(((PyObject*)(ifixx)));
Py_XDECREF(stpb)_Py_XDECREF(((PyObject*)(stpb)));
Py_XDECREF(stpd)_Py_XDECREF(((PyObject*)(stpd)));
Py_XDECREF(sclb)_Py_XDECREF(((PyObject*)(sclb)));
Py_XDECREF(scld)_Py_XDECREF(((PyObject*)(scld)));
Py_XDECREF(work)_Py_XDECREF(((PyObject*)(work)));
Py_XDECREF(iwork)_Py_XDECREF(((PyObject*)(iwork)));

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


1262PyObject *set_exceptions(PyObject * self, PyObject * args, PyObject * kwds)
1263{
  PyObject *exc_error, *exc_stop;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "OO", &exc_error, &exc_stop))
return NULL((void*)0);

  Py_INCREF(exc_stop)_Py_INCREF(((PyObject*)(exc_stop)));
  Py_INCREF(exc_error)_Py_INCREF(((PyObject*)(exc_error)));
  odr_stop = exc_stop;
  odr_error = exc_error;

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
1276}

1278static PyMethodDef methods[] = {
{"_set_exceptions", (PyCFunction) set_exceptions, METH_VARARGS0x0001, NULL((void*)0)},
{"odr", (PyCFunction) odr, METH_VARARGS0x0001 | METH_KEYWORDS0x0002, NULL((void*)0)},
{NULL((void*)0), NULL((void*)0)},
1282};

1284static struct PyModuleDef moduledef = {
  PyModuleDef_HEAD_INIT{ { 1, ((void*)0) }, ((void*)0), 0, ((void*)0), },
  "_odrpack",
  NULL((void*)0),
  -1,
  methods,
  NULL((void*)0),
  NULL((void*)0),
  NULL((void*)0),
  NULL((void*)0)
1294};

1296PyObject *PyInit___odrpack(void)
1297{
  PyObject *m;
  import_array(){if (_import_array() < 0) {PyErr_Print(); PyErr_SetString(
PyExc_ImportError, "numpy.core.multiarray failed to import");
 return ((void*)0); } };
  m = PyModule_Create(&moduledef)PyModule_Create2(&moduledef, 1013);
  return m;
1302}

←

/opt/pyrefcon/lib/pyrefcon/models/models/PyTuple_SetItem.model

1#ifndef PyTuple_SetItem
2struct _object;
3typedef struct _object PyObject;
4void clang_analyzer_PyObject_Steal_Reference(const void *);
5int clang_analyzer_noimpl_conjure_int();
6int PyTuple_SetItem(PyObject *p, Py_ssize_t pos, PyObject *o) {
7  clang_analyzer_PyObject_Steal_Reference(o);
4
←
Setting reference count to -1→
8  return clang_analyzer_noimpl_conjure_int();
9}
10#else
11#warning "API PyTuple_SetItem is defined as a macro."
12#endif