/* File: slalibmodule.c
 * This file is auto-generated with f2py (version:2_4422).
 * f2py is a Fortran to Python Interface Generator (FPIG), Second Edition,
 * written by Pearu Peterson <pearu@cens.ioc.ee>.
 * See http://cens.ioc.ee/projects/f2py2e/
 * Generation date: Mon Jul 21 11:06:00 2008
 * $Revision:$
 * $Date:$
 * Do not edit this file directly unless you know what you are doing!!!
 */
#ifdef __cplusplus
extern "C" {
#endif

/*********************** See f2py2e/cfuncs.py: includes ***********************/
#include "Python.h"
#include "fortranobject.h"
#include <string.h>
#include <math.h>

/**************** See f2py2e/rules.py: mod_rules['modulebody'] ****************/
static PyObject *slalib_error;
static PyObject *slalib_module;

/*********************** See f2py2e/cfuncs.py: typedefs ***********************/
typedef char * string;

/****************** See f2py2e/cfuncs.py: typedefs_generated ******************/
/*need_typedefs_generated*/

/********************** See f2py2e/cfuncs.py: cppmacros **********************/
\
#define FAILNULL(p) do {                                            \
    if ((p) == NULL) {                                              \
        PyErr_SetString(PyExc_MemoryError, "NULL pointer found");   \
        goto capi_fail;                                             \
    }                                                               \
} while (0)

#define STRINGMALLOC(str,len)\
  if ((str = (string)malloc(sizeof(char)*(len+1))) == NULL) {\
    PyErr_SetString(PyExc_MemoryError, "out of memory");\
    goto capi_fail;\
  } else {\
    (str)[len] = '\0';\
  }

#if defined(PREPEND_FORTRAN)
#if defined(NO_APPEND_FORTRAN)
#if defined(UPPERCASE_FORTRAN)
#define F_FUNC(f,F) _##F
#else
#define F_FUNC(f,F) _##f
#endif
#else
#if defined(UPPERCASE_FORTRAN)
#define F_FUNC(f,F) _##F##_
#else
#define F_FUNC(f,F) _##f##_
#endif
#endif
#else
#if defined(NO_APPEND_FORTRAN)
#if defined(UPPERCASE_FORTRAN)
#define F_FUNC(f,F) F
#else
#define F_FUNC(f,F) f
#endif
#else
#if defined(UPPERCASE_FORTRAN)
#define F_FUNC(f,F) F##_
#else
#define F_FUNC(f,F) f##_
#endif
#endif
#endif
#if defined(UNDERSCORE_G77)
#define F_FUNC_US(f,F) F_FUNC(f##_,F##_)
#else
#define F_FUNC_US(f,F) F_FUNC(f,F)
#endif

#ifdef DEBUGCFUNCS
#define CFUNCSMESS(mess) fprintf(stderr,"debug-capi:"mess);
#define CFUNCSMESSPY(mess,obj) CFUNCSMESS(mess) \
  PyObject_Print((PyObject *)obj,stderr,Py_PRINT_RAW);\
  fprintf(stderr,"\n");
#else
#define CFUNCSMESS(mess)
#define CFUNCSMESSPY(mess,obj)
#endif

#ifndef MAX
#define MAX(a,b) ((a > b) ? (a) : (b))
#endif
#ifndef MIN
#define MIN(a,b) ((a < b) ? (a) : (b))
#endif

#define rank(var) var ## _Rank
#define shape(var,dim) var ## _Dims[dim]
#define old_rank(var) (((PyArrayObject *)(capi_ ## var ## _tmp))->nd)
#define old_shape(var,dim) (((PyArrayObject *)(capi_ ## var ## _tmp))->dimensions[dim])
#define fshape(var,dim) shape(var,rank(var)-dim-1)
#define len(var) shape(var,0)
#define flen(var) fshape(var,0)
#define size(var) PyArray_SIZE((PyArrayObject *)(capi_ ## var ## _tmp))
/* #define index(i) capi_i ## i */
#define slen(var) capi_ ## var ## _len

#define STRINGFREE(str) do {if (!(str == NULL)) free(str);} while (0)

#if defined(PREPEND_FORTRAN)
#if defined(NO_APPEND_FORTRAN)
#if defined(UPPERCASE_FORTRAN)
#define F_WRAPPEDFUNC(f,F) _F2PYWRAP##F
#else
#define F_WRAPPEDFUNC(f,F) _f2pywrap##f
#endif
#else
#if defined(UPPERCASE_FORTRAN)
#define F_WRAPPEDFUNC(f,F) _F2PYWRAP##F##_
#else
#define F_WRAPPEDFUNC(f,F) _f2pywrap##f##_
#endif
#endif
#else
#if defined(NO_APPEND_FORTRAN)
#if defined(UPPERCASE_FORTRAN)
#define F_WRAPPEDFUNC(f,F) F2PYWRAP##F
#else
#define F_WRAPPEDFUNC(f,F) f2pywrap##f
#endif
#else
#if defined(UPPERCASE_FORTRAN)
#define F_WRAPPEDFUNC(f,F) F2PYWRAP##F##_
#else
#define F_WRAPPEDFUNC(f,F) f2pywrap##f##_
#endif
#endif
#endif
#if defined(UNDERSCORE_G77)
#define F_WRAPPEDFUNC_US(f,F) F_WRAPPEDFUNC(f##_,F##_)
#else
#define F_WRAPPEDFUNC_US(f,F) F_WRAPPEDFUNC(f,F)
#endif

#define CHECKSCALAR(check,tcheck,name,show,var)\
  if (!(check)) {\
    PyErr_SetString(slalib_error,"("tcheck") failed for "name);\
    fprintf(stderr,show"\n",var);\
    /*goto capi_fail;*/\
  } else 
#define STRINGCOPYN(to,from,buf_size)                           \
    do {                                                        \
        int _m = (buf_size);                                    \
        char *_to = (to);                                       \
        char *_from = (from);                                   \
        FAILNULL(_to); FAILNULL(_from);                         \
        (void)strncpy(_to, _from, sizeof(char)*_m);             \
        _to[_m-1] = '\0';                                      \
        /* Padding with spaces instead of nulls */              \
        for (_m -= 2; _m >= 0 && _to[_m] == '\0'; _m--) {      \
            _to[_m] = ' ';                                      \
        }                                                       \
    } while (0)


/************************ See f2py2e/cfuncs.py: cfuncs ************************/
static int double_from_pyobj(double* v,PyObject *obj,const char *errmess) {
  PyObject* tmp = NULL;
  if (PyFloat_Check(obj)) {
#ifdef __sgi
    *v = PyFloat_AsDouble(obj);
#else
    *v = PyFloat_AS_DOUBLE(obj);
#endif
    return 1;
  }
  tmp = PyNumber_Float(obj);
  if (tmp) {
#ifdef __sgi
    *v = PyFloat_AsDouble(tmp);
#else
    *v = PyFloat_AS_DOUBLE(tmp);
#endif
    Py_DECREF(tmp);
    return 1;
  }
  if (PyComplex_Check(obj))
    tmp = PyObject_GetAttrString(obj,"real");
  else if (PyString_Check(obj))
    /*pass*/;
  else if (PySequence_Check(obj))
    tmp = PySequence_GetItem(obj,0);
  if (tmp) {
    PyErr_Clear();
    if (double_from_pyobj(v,tmp,errmess)) {Py_DECREF(tmp); return 1;}
    Py_DECREF(tmp);
  }
  {
    PyObject* err = PyErr_Occurred();
    if (err==NULL) err = slalib_error;
    PyErr_SetString(err,errmess);
  }
  return 0;
}

static int int_from_pyobj(int* v,PyObject *obj,const char *errmess) {
  PyObject* tmp = NULL;
  if (PyInt_Check(obj)) {
    *v = (int)PyInt_AS_LONG(obj);
    return 1;
  }
  tmp = PyNumber_Int(obj);
  if (tmp) {
    *v = PyInt_AS_LONG(tmp);
    Py_DECREF(tmp);
    return 1;
  }
  if (PyComplex_Check(obj))
    tmp = PyObject_GetAttrString(obj,"real");
  else if (PyString_Check(obj))
    /*pass*/;
  else if (PySequence_Check(obj))
    tmp = PySequence_GetItem(obj,0);
  if (tmp) {
    PyErr_Clear();
    if (int_from_pyobj(v,tmp,errmess)) {Py_DECREF(tmp); return 1;}
    Py_DECREF(tmp);
  }
  {
    PyObject* err = PyErr_Occurred();
    if (err==NULL) err = slalib_error;
    PyErr_SetString(err,errmess);
  }
  return 0;
}

static int string_from_pyobj(string *str,int *len,const string inistr,PyObject *obj,const char *errmess) {
  PyArrayObject *arr = NULL;
  PyObject *tmp = NULL;
#ifdef DEBUGCFUNCS
fprintf(stderr,"string_from_pyobj(str='%s',len=%d,inistr='%s',obj=%p)\n",(char*)str,*len,(char *)inistr,obj);
#endif
  if (obj == Py_None) {
    if (*len == -1)
      *len = strlen(inistr); /* Will this cause problems? */
    STRINGMALLOC(*str,*len);
    STRINGCOPYN(*str,inistr,*len+1);
    return 1;
  }
  if (PyArray_Check(obj)) {
    if ((arr = (PyArrayObject *)obj) == NULL)
      goto capi_fail;
    if (!ISCONTIGUOUS(arr)) {
      PyErr_SetString(PyExc_ValueError,"array object is non-contiguous.");
      goto capi_fail;
    }
    if (*len == -1)
      *len = (arr->descr->elsize)*PyArray_SIZE(arr);
    STRINGMALLOC(*str,*len);
    STRINGCOPYN(*str,arr->data,*len+1);
    return 1;
  }
  if (PyString_Check(obj)) {
    tmp = obj;
    Py_INCREF(tmp);
  }
  else
    tmp = PyObject_Str(obj);
  if (tmp == NULL) goto capi_fail;
  if (*len == -1)
    *len = PyString_GET_SIZE(tmp);
  STRINGMALLOC(*str,*len);
  STRINGCOPYN(*str,PyString_AS_STRING(tmp),*len+1);
  Py_DECREF(tmp);
  return 1;
capi_fail:
  Py_XDECREF(tmp);
  {
    PyObject* err = PyErr_Occurred();
    if (err==NULL) err = slalib_error;
    PyErr_SetString(err,errmess);
  }
  return 0;
}

static int float_from_pyobj(float* v,PyObject *obj,const char *errmess) {
  double d=0.0;
  if (double_from_pyobj(&d,obj,errmess)) {
    *v = (float)d;
    return 1;
  }
  return 0;
}


/********************* See f2py2e/cfuncs.py: userincludes *********************/
/*need_userincludes*/

/********************* See f2py2e/capi_rules.py: usercode *********************/


/* See f2py2e/rules.py */
extern void F_FUNC_US(sla_addet,SLA_ADDET)(double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_afin,SLA_AFIN)(string,int*,float*,int*,size_t);
extern void F_WRAPPEDFUNC_US(sla_airmas,SLA_AIRMAS)(double*,double*);
extern void F_FUNC_US(sla_altaz,SLA_ALTAZ)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_amp,SLA_AMP)(double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_ampqk,SLA_AMPQK)(double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_aop,SLA_AOP)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_aoppa,SLA_AOPPA)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_aoppat,SLA_AOPPAT)(double*,double*);
extern void F_FUNC_US(sla_aopqk,SLA_AOPQK)(double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_atmdsp,SLA_ATMDSP)(double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla__atms,SLA__ATMS)(double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla__atmt,SLA__ATMT)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_av2m,SLA_AV2M)(float*,float*);
extern void F_WRAPPEDFUNC_US(sla_bear,SLA_BEAR)(float*,float*,float*,float*,float*);
extern void F_FUNC_US(sla_caf2r,SLA_CAF2R)(int*,int*,float*,float*,int*);
extern void F_FUNC_US(sla_caldj,SLA_CALDJ)(int*,int*,int*,double*,int*);
extern void F_FUNC_US(sla_calyd,SLA_CALYD)(int*,int*,int*,int*,int*,int*);
extern void F_FUNC_US(sla_cc2s,SLA_CC2S)(float*,float*,float*);
extern void F_FUNC_US(sla_cc62s,SLA_CC62S)(float*,float*,float*,float*,float*,float*,float*);
extern void F_FUNC_US(sla_cd2tf,SLA_CD2TF)(int*,float*,string,int*,size_t);
extern void F_FUNC_US(sla_cldj,SLA_CLDJ)(int*,int*,int*,double*,int*);
extern void F_FUNC_US(sla_clyd,SLA_CLYD)(int*,int*,int*,int*,int*,int*);
extern void F_FUNC_US(sla_combn,SLA_COMBN)(int*,int*,int*,int*);
extern void F_FUNC_US(sla_cr2af,SLA_CR2AF)(int*,float*,string,int*,size_t);
extern void F_FUNC_US(sla_cr2tf,SLA_CR2TF)(int*,float*,string,int*,size_t);
extern void F_FUNC_US(sla_cs2c6,SLA_CS2C6)(float*,float*,float*,float*,float*,float*,float*);
extern void F_FUNC_US(sla_cs2c,SLA_CS2C)(float*,float*,float*);
extern void F_FUNC_US(sla_ctf2d,SLA_CTF2D)(int*,int*,float*,float*,int*);
extern void F_FUNC_US(sla_ctf2r,SLA_CTF2R)(int*,int*,float*,float*,int*);
extern void F_FUNC_US(sla_daf2r,SLA_DAF2R)(int*,int*,double*,double*,int*);
extern void F_FUNC_US(sla_dafin,SLA_DAFIN)(string,int*,double*,int*,size_t);
extern void F_WRAPPEDFUNC_US(sla_dat,SLA_DAT)(double*,double*);
extern void F_FUNC_US(sla_dav2m,SLA_DAV2M)(double*,double*);
extern void F_WRAPPEDFUNC_US(sla_dbear,SLA_DBEAR)(double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_dbjin,SLA_DBJIN)(string,int*,double*,int*,int*,size_t);
extern void F_FUNC_US(sla_dc62s,SLA_DC62S)(double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_dcc2s,SLA_DCC2S)(double*,double*,double*);
extern void F_FUNC_US(sla_dcmpf,SLA_DCMPF)(double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_dcs2c,SLA_DCS2C)(double*,double*,double*);
extern void F_FUNC_US(sla_dd2tf,SLA_DD2TF)(int*,double*,string,int*,size_t);
extern void F_FUNC_US(sla_de2h,SLA_DE2H)(double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_deuler,SLA_DEULER)(string,double*,double*,double*,double*,size_t);
extern void F_FUNC_US(sla_dfltin,SLA_DFLTIN)(string,int*,double*,int*,size_t);
extern void F_FUNC_US(sla_dh2e,SLA_DH2E)(double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_dimxv,SLA_DIMXV)(double*,double*,double*);
extern void F_FUNC_US(sla_djcal,SLA_DJCAL)(int*,double*,int*,int*);
extern void F_FUNC_US(sla_djcl,SLA_DJCL)(double*,int*,int*,int*,double*,int*);
extern void F_FUNC_US(sla_dm2av,SLA_DM2AV)(double*,double*);
extern void F_FUNC_US(sla_dmat,SLA_DMAT)(int*,double*,double*,double*,int*,int*);
extern void F_FUNC_US(sla_dmoon,SLA_DMOON)(double*,double*);
extern void F_FUNC_US(sla_dmxm,SLA_DMXM)(double*,double*,double*);
extern void F_FUNC_US(sla_dmxv,SLA_DMXV)(double*,double*,double*);
extern void F_WRAPPEDFUNC_US(sla_dpav,SLA_DPAV)(double*,double*,double*);
extern void F_FUNC_US(sla_dr2af,SLA_DR2AF)(int*,double*,string,int*,size_t);
extern void F_FUNC_US(sla_dr2tf,SLA_DR2TF)(int*,double*,string,int*,size_t);
extern void F_WRAPPEDFUNC_US(sla_drange,SLA_DRANGE)(double*,double*);
extern void F_WRAPPEDFUNC_US(sla_dranrm,SLA_DRANRM)(double*,double*);
extern void F_FUNC_US(sla_ds2c6,SLA_DS2C6)(double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_ds2tp,SLA_DS2TP)(double*,double*,double*,double*,double*,double*,int*);
extern void F_WRAPPEDFUNC_US(sla_dsep,SLA_DSEP)(double*,double*,double*,double*,double*);
extern void F_WRAPPEDFUNC_US(sla_dsepv,SLA_DSEPV)(double*,double*,double*);
extern void F_WRAPPEDFUNC_US(sla_dt,SLA_DT)(double*,double*);
extern void F_FUNC_US(sla_dtf2d,SLA_DTF2D)(int*,int*,double*,double*,int*);
extern void F_FUNC_US(sla_dtf2r,SLA_DTF2R)(int*,int*,double*,double*,int*);
extern void F_FUNC_US(sla_dtp2s,SLA_DTP2S)(double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_dtp2v,SLA_DTP2V)(double*,double*,double*,double*);
extern void F_FUNC_US(sla_dtps2c,SLA_DTPS2C)(double*,double*,double*,double*,double*,double*,double*,double*,int*);
extern void F_FUNC_US(sla_dtpv2c,SLA_DTPV2C)(double*,double*,double*,double*,double*,int*);
extern void F_WRAPPEDFUNC_US(sla_dtt,SLA_DTT)(double*,double*);
extern void F_FUNC_US(sla_dv2tp,SLA_DV2TP)(double*,double*,double*,double*,int*);
extern void F_WRAPPEDFUNC_US(sla_dvdv,SLA_DVDV)(double*,double*,double*);
extern void F_FUNC_US(sla_dvn,SLA_DVN)(double*,double*,double*);
extern void F_FUNC_US(sla_dvxv,SLA_DVXV)(double*,double*,double*);
extern void F_FUNC_US(sla_e2h,SLA_E2H)(float*,float*,float*,float*,float*);
extern void F_FUNC_US(sla_earth,SLA_EARTH)(int*,int*,float*,float*);
extern void F_FUNC_US(sla_ecleq,SLA_ECLEQ)(double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_ecmat,SLA_ECMAT)(double*,double*);
extern void F_FUNC_US(sla_ecor,SLA_ECOR)(float*,float*,int*,int*,float*,float*,float*);
extern void F_FUNC_US(sla_eg50,SLA_EG50)(double*,double*,double*,double*);
extern void F_FUNC_US(sla_el2ue,SLA_EL2UE)(double*,int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*);
extern void F_WRAPPEDFUNC_US(sla_epb2d,SLA_EPB2D)(double*,double*);
extern void F_WRAPPEDFUNC_US(sla_epb,SLA_EPB)(double*,double*);
extern void F_WRAPPEDFUNC_US(sla_epco,SLA_EPCO)(double*,string,string,double*,size_t,size_t);
extern void F_WRAPPEDFUNC_US(sla_epj2d,SLA_EPJ2D)(double*,double*);
extern void F_WRAPPEDFUNC_US(sla_epj,SLA_EPJ)(double*,double*);
extern void F_FUNC_US(sla_epv,SLA_EPV)(double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_eqecl,SLA_EQECL)(double*,double*,double*,double*,double*);
extern void F_WRAPPEDFUNC_US(sla_eqeqx,SLA_EQEQX)(double*,double*);
extern void F_FUNC_US(sla_eqgal,SLA_EQGAL)(double*,double*,double*,double*);
extern void F_FUNC_US(sla_etrms,SLA_ETRMS)(double*,double*);
extern void F_FUNC_US(sla_euler,SLA_EULER)(string,float*,float*,float*,float*,size_t);
extern void F_FUNC_US(sla_evp,SLA_EVP)(double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_fitxy,SLA_FITXY)(int*,int*,double*,double*,double*,int*);
extern void F_FUNC_US(sla_fk425,SLA_FK425)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_fk45z,SLA_FK45Z)(double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_fk524,SLA_FK524)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_fk52h,SLA_FK52H)(double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_fk54z,SLA_FK54Z)(double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_fk5hz,SLA_FK5HZ)(double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_flotin,SLA_FLOTIN)(string,int*,float*,int*,size_t);
extern void F_FUNC_US(sla_galeq,SLA_GALEQ)(double*,double*,double*,double*);
extern void F_FUNC_US(sla_galsup,SLA_GALSUP)(double*,double*,double*,double*);
extern void F_FUNC_US(sla_ge50,SLA_GE50)(double*,double*,double*,double*);
extern void F_FUNC_US(sla_geoc,SLA_GEOC)(double*,double*,double*,double*);
extern void F_WRAPPEDFUNC_US(sla_gmsta,SLA_GMSTA)(double*,double*,double*);
extern void F_WRAPPEDFUNC_US(sla_gmst,SLA_GMST)(double*,double*);
extern void F_FUNC_US(sla_h2e,SLA_H2E)(float*,float*,float*,float*,float*);
extern void F_FUNC_US(sla_h2fk5,SLA_H2FK5)(double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_hfk5z,SLA_HFK5Z)(double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla__idchf,SLA__IDCHF)(string,int*,int*,int*,double*,size_t);
extern void F_FUNC_US(sla__idchi,SLA__IDCHI)(string,int*,int*,double*,size_t);
extern void F_FUNC_US(sla_imxv,SLA_IMXV)(float*,float*,float*);
extern void F_FUNC_US(sla_intin,SLA_INTIN)(string,int*,int*,int*,size_t);
extern void F_FUNC_US(sla_invf,SLA_INVF)(double*,double*,int*);
extern void F_FUNC_US(sla_kbj,SLA_KBJ)(int*,double*,string,int*,size_t);
extern void F_FUNC_US(sla_m2av,SLA_M2AV)(float*,float*);
extern void F_FUNC_US(sla_map,SLA_MAP)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_mappa,SLA_MAPPA)(double*,double*,double*);
extern void F_FUNC_US(sla_mapqk,SLA_MAPQK)(double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_mapqkz,SLA_MAPQKZ)(double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_moon,SLA_MOON)(int*,int*,float*,float*);
extern void F_FUNC_US(sla_mxm,SLA_MXM)(float*,float*,float*);
extern void F_FUNC_US(sla_mxv,SLA_MXV)(float*,float*,float*);
extern void F_FUNC_US(sla_nutc80,SLA_NUTC80)(double*,double*,double*,double*);
extern void F_FUNC_US(sla_nutc,SLA_NUTC)(double*,double*,double*,double*);
extern void F_FUNC_US(sla_nut,SLA_NUT)(double*,double*);
extern void F_FUNC_US(sla_oap,SLA_OAP)(string,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,size_t);
extern void F_FUNC_US(sla_oapqk,SLA_OAPQK)(string,double*,double*,double*,double*,double*,size_t);
extern void F_FUNC_US(sla_obs,SLA_OBS)(int*,string,string,double*,double*,double*,size_t,size_t);
extern void F_WRAPPEDFUNC_US(sla_pa,SLA_PA)(double*,double*,double*,double*);
extern void F_WRAPPEDFUNC_US(sla_pav,SLA_PAV)(float*,float*,float*);
extern void F_FUNC_US(sla_pcd,SLA_PCD)(double*,double*,double*);
extern void F_FUNC_US(sla_pda2h,SLA_PDA2H)(double*,double*,double*,double*,int*,double*,int*);
extern void F_FUNC_US(sla_pdq2h,SLA_PDQ2H)(double*,double*,double*,double*,int*,double*,int*);
extern void F_FUNC_US(sla_permut,SLA_PERMUT)(int*,int*,int*,int*);
extern void F_FUNC_US(sla_pertel,SLA_PERTEL)(int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*);
extern void F_FUNC_US(sla_pertue,SLA_PERTUE)(double*,double*,int*);
extern void F_FUNC_US(sla_planel,SLA_PLANEL)(double*,int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*);
extern void F_FUNC_US(sla_planet,SLA_PLANET)(double*,int*,double*,int*);
extern void F_FUNC_US(sla_plante,SLA_PLANTE)(double*,double*,double*,int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*);
extern void F_FUNC_US(sla_plantu,SLA_PLANTU)(double*,double*,double*,double*,double*,double*,double*,int*);
extern void F_FUNC_US(sla_pm,SLA_PM)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_polmo,SLA_POLMO)(double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_prebn,SLA_PREBN)(double*,double*,double*);
extern void F_FUNC_US(sla_preces,SLA_PRECES)(string,double*,double*,double*,double*,size_t);
extern void F_FUNC_US(sla_prec,SLA_PREC)(double*,double*,double*);
extern void F_FUNC_US(sla_precl,SLA_PRECL)(double*,double*,double*);
extern void F_FUNC_US(sla_prenut,SLA_PRENUT)(double*,double*,double*);
extern void F_FUNC_US(sla_pv2el,SLA_PV2EL)(double*,double*,double*,int*,int*,double*,double*,double*,double*,double*,double*,double*,double*,int*);
extern void F_FUNC_US(sla_pv2ue,SLA_PV2UE)(double*,double*,double*,double*,int*);
extern void F_FUNC_US(sla_pvobs,SLA_PVOBS)(double*,double*,double*,double*);
extern void F_FUNC_US(sla_pxy,SLA_PXY)(int*,double*,double*,double*,double*,double*,double*,double*);
extern void F_WRAPPEDFUNC_US(sla_range,SLA_RANGE)(float*,float*);
extern void F_WRAPPEDFUNC_US(sla_ranorm,SLA_RANORM)(float*,float*);
extern void F_WRAPPEDFUNC_US(sla_rcc,SLA_RCC)(double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_rdplan,SLA_RDPLAN)(double*,int*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_refco,SLA_REFCO)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_refcoq,SLA_REFCOQ)(double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_refro,SLA_REFRO)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_refv,SLA_REFV)(double*,double*,double*,double*);
extern void F_FUNC_US(sla_refz,SLA_REFZ)(double*,double*,double*,double*);
extern void F_WRAPPEDFUNC_US(sla_rverot,SLA_RVEROT)(float*,float*,float*,float*,float*);
extern void F_WRAPPEDFUNC_US(sla_rvgalc,SLA_RVGALC)(float*,float*,float*);
extern void F_WRAPPEDFUNC_US(sla_rvlg,SLA_RVLG)(float*,float*,float*);
extern void F_WRAPPEDFUNC_US(sla_rvlsrd,SLA_RVLSRD)(float*,float*,float*);
extern void F_WRAPPEDFUNC_US(sla_rvlsrk,SLA_RVLSRK)(float*,float*,float*);
extern void F_FUNC_US(sla_s2tp,SLA_S2TP)(float*,float*,float*,float*,float*,float*,int*);
extern void F_WRAPPEDFUNC_US(sla_sep,SLA_SEP)(float*,float*,float*,float*,float*);
extern void F_WRAPPEDFUNC_US(sla_sepv,SLA_SEPV)(float*,float*,float*);
extern void F_FUNC_US(sla_smat,SLA_SMAT)(int*,float*,float*,float*,int*,int*);
extern void F_FUNC_US(sla_subet,SLA_SUBET)(double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_supgal,SLA_SUPGAL)(double*,double*,double*,double*);
extern void F_FUNC_US(sla_svdcov,SLA_SVDCOV)(int*,int*,int*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_svd,SLA_SVD)(int*,int*,int*,int*,double*,double*,double*,double*,int*);
extern void F_FUNC_US(sla_svdsol,SLA_SVDSOL)(int*,int*,int*,int*,double*,double*,double*,double*,double*,double*);
extern void F_FUNC_US(sla_tp2s,SLA_TP2S)(float*,float*,float*,float*,float*,float*);
extern void F_FUNC_US(sla_tp2v,SLA_TP2V)(float*,float*,float*,float*);
extern void F_FUNC_US(sla_tps2c,SLA_TPS2C)(float*,float*,float*,float*,float*,float*,float*,float*,int*);
extern void F_FUNC_US(sla_tpv2c,SLA_TPV2C)(float*,float*,float*,float*,float*,int*);
extern void F_FUNC_US(sla_ue2el,SLA_UE2EL)(double*,int*,int*,double*,double*,double*,double*,double*,double*,double*,double*,int*);
extern void F_FUNC_US(sla_ue2pv,SLA_UE2PV)(double*,double*,double*,int*);
extern void F_FUNC_US(sla_unpcd,SLA_UNPCD)(double*,double*,double*);
extern void F_FUNC_US(sla_v2tp,SLA_V2TP)(float*,float*,float*,float*,int*);
extern void F_WRAPPEDFUNC_US(sla_vdv,SLA_VDV)(float*,float*,float*);
extern void F_WRAPPEDFUNC_US(sla_veri,SLA_VERI)(int*);
extern void F_FUNC_US(sla_vn,SLA_VN)(float*,float*,float*);
extern void F_FUNC_US(sla_vxv,SLA_VXV)(float*,float*,float*);
extern void F_FUNC_US(sla_wait,SLA_WAIT)(float*);
extern void F_FUNC_US(sla_xy2xy,SLA_XY2XY)(double*,double*,double*,double*,double*);
extern void F_WRAPPEDFUNC_US(sla_zd,SLA_ZD)(double*,double*,double*,double*);
/*eof externroutines*/

/******************** See f2py2e/capi_rules.py: usercode1 ********************/


/******************* See f2py2e/cb_rules.py: buildcallback *******************/
/*need_callbacks*/

/*********************** See f2py2e/rules.py: buildapi ***********************/

/********************************* sla_addet *********************************/
static char doc_f2py_rout_slalib_sla_addet[] = "\
Function signature:\n\
  rc,dc = sla_addet(rm,dm,eq)\n\
Required arguments:\n"
"  rm : input float\n"
"  dm : input float\n"
"  eq : input float\n"
"Return objects:\n"
"  rc : float\n"
"  dc : float";
/* extern void F_FUNC_US(sla_addet,SLA_ADDET)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_addet(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double rm = 0;
  PyObject *rm_capi = Py_None;
  double dm = 0;
  PyObject *dm_capi = Py_None;
  double eq = 0;
  PyObject *eq_capi = Py_None;
  double rc = 0;
  double dc = 0;
  static char *capi_kwlist[] = {"rm","dm","eq",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_addet",\
    capi_kwlist,&rm_capi,&dm_capi,&eq_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rm */
    f2py_success = double_from_pyobj(&rm,rm_capi,"slalib.sla_addet() 1st argument (rm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dm */
    f2py_success = double_from_pyobj(&dm,dm_capi,"slalib.sla_addet() 2nd argument (dm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable eq */
    f2py_success = double_from_pyobj(&eq,eq_capi,"slalib.sla_addet() 3rd argument (eq) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dc */
  /* Processing variable rc */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&rm,&dm,&eq,&rc,&dc);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",rc,dc);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable rc */
  /* End of cleaning variable dc */
  } /*if (f2py_success) of eq*/
  /* End of cleaning variable eq */
  } /*if (f2py_success) of dm*/
  /* End of cleaning variable dm */
  } /*if (f2py_success) of rm*/
  /* End of cleaning variable rm */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_addet ******************************/

/********************************** sla_afin **********************************/
static char doc_f2py_rout_slalib_sla_afin[] = "\
Function signature:\n\
  iptr,a,j = sla_afin(string_bn,iptr)\n\
Required arguments:\n"
"  string_bn : input string(len=-1)\n"
"  iptr : input int\n"
"Return objects:\n"
"  iptr : int\n"
"  a : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_afin,SLA_AFIN)(string,int*,float*,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_afin(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,int*,float*,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string string_bn = NULL;
  int slen(string_bn);
  PyObject *string_bn_capi = Py_None;
  int iptr = 0;
  PyObject *iptr_capi = Py_None;
  float a = 0;
  int j = 0;
  static char *capi_kwlist[] = {"string_bn","iptr",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_afin",\
    capi_kwlist,&string_bn_capi,&iptr_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
  /* Processing variable iptr */
    f2py_success = int_from_pyobj(&iptr,iptr_capi,"slalib.sla_afin() 2nd argument (iptr) can't be converted to int");
  if (f2py_success) {
  /* Processing variable j */
  /* Processing variable string_bn */
  slen(string_bn) = -1;
  f2py_success = string_from_pyobj(&string_bn,&slen(string_bn),"",string_bn_capi,"string_from_pyobj failed in converting 1st argument `string_bn' of slalib.sla_afin to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(string_bn,&iptr,&a,&j,slen(string_bn));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ifi",iptr,a,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(string_bn);
  }  /*if (f2py_success) of string_bn*/
  /* End of cleaning variable string_bn */
  /* End of cleaning variable j */
  } /*if (f2py_success) of iptr*/
  /* End of cleaning variable iptr */
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_afin ******************************/

/********************************* sla_airmas *********************************/
static char doc_f2py_rout_slalib_sla_airmas[] = "\
Function signature:\n\
  sla_airmas = sla_airmas(zd)\n\
Required arguments:\n"
"  zd : input float\n"
"Return objects:\n"
"  sla_airmas : float";
/* extern void F_WRAPPEDFUNC_US(sla_airmas,SLA_AIRMAS)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_airmas(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_airmas = 0;
  double zd = 0;
  PyObject *zd_capi = Py_None;
  static char *capi_kwlist[] = {"zd",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_airmas",\
    capi_kwlist,&zd_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable zd */
    f2py_success = double_from_pyobj(&zd,zd_capi,"slalib.sla_airmas() 1st argument (zd) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_airmas */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_airmas,&zd);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_airmas);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_airmas */
  } /*if (f2py_success) of zd*/
  /* End of cleaning variable zd */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_airmas *****************************/

/********************************* sla_altaz *********************************/
static char doc_f2py_rout_slalib_sla_altaz[] = "\
Function signature:\n\
  az,azd,azdd,el,eld,eldd,pa,pad,padd = sla_altaz(ha,dec,phi)\n\
Required arguments:\n"
"  ha : input float\n"
"  dec : input float\n"
"  phi : input float\n"
"Return objects:\n"
"  az : float\n"
"  azd : float\n"
"  azdd : float\n"
"  el : float\n"
"  eld : float\n"
"  eldd : float\n"
"  pa : float\n"
"  pad : float\n"
"  padd : float";
/* extern void F_FUNC_US(sla_altaz,SLA_ALTAZ)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_altaz(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double ha = 0;
  PyObject *ha_capi = Py_None;
  double dec = 0;
  PyObject *dec_capi = Py_None;
  double phi = 0;
  PyObject *phi_capi = Py_None;
  double az = 0;
  double azd = 0;
  double azdd = 0;
  double el = 0;
  double eld = 0;
  double eldd = 0;
  double pa = 0;
  double pad = 0;
  double padd = 0;
  static char *capi_kwlist[] = {"ha","dec","phi",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_altaz",\
    capi_kwlist,&ha_capi,&dec_capi,&phi_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable el */
  /* Processing variable phi */
    f2py_success = double_from_pyobj(&phi,phi_capi,"slalib.sla_altaz() 3rd argument (phi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable az */
  /* Processing variable padd */
  /* Processing variable eldd */
  /* Processing variable azd */
  /* Processing variable azdd */
  /* Processing variable eld */
  /* Processing variable pa */
  /* Processing variable pad */
  /* Processing variable ha */
    f2py_success = double_from_pyobj(&ha,ha_capi,"slalib.sla_altaz() 1st argument (ha) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dec */
    f2py_success = double_from_pyobj(&dec,dec_capi,"slalib.sla_altaz() 2nd argument (dec) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ha,&dec,&phi,&az,&azd,&azdd,&el,&eld,&eldd,&pa,&pad,&padd);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ddddddddd",az,azd,azdd,el,eld,eldd,pa,pad,padd);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of dec*/
  /* End of cleaning variable dec */
  } /*if (f2py_success) of ha*/
  /* End of cleaning variable ha */
  /* End of cleaning variable pad */
  /* End of cleaning variable pa */
  /* End of cleaning variable eld */
  /* End of cleaning variable azdd */
  /* End of cleaning variable azd */
  /* End of cleaning variable eldd */
  /* End of cleaning variable padd */
  /* End of cleaning variable az */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
  /* End of cleaning variable el */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_altaz ******************************/

/********************************** sla_amp **********************************/
static char doc_f2py_rout_slalib_sla_amp[] = "\
Function signature:\n\
  rm,dm = sla_amp(ra,da,date,eq)\n\
Required arguments:\n"
"  ra : input float\n"
"  da : input float\n"
"  date : input float\n"
"  eq : input float\n"
"Return objects:\n"
"  rm : float\n"
"  dm : float";
/* extern void F_FUNC_US(sla_amp,SLA_AMP)(double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_amp(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double ra = 0;
  PyObject *ra_capi = Py_None;
  double da = 0;
  PyObject *da_capi = Py_None;
  double date = 0;
  PyObject *date_capi = Py_None;
  double eq = 0;
  PyObject *eq_capi = Py_None;
  double rm = 0;
  double dm = 0;
  static char *capi_kwlist[] = {"ra","da","date","eq",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_amp",\
    capi_kwlist,&ra_capi,&da_capi,&date_capi,&eq_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dm */
  /* Processing variable ra */
    f2py_success = double_from_pyobj(&ra,ra_capi,"slalib.sla_amp() 1st argument (ra) can't be converted to double");
  if (f2py_success) {
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_amp() 3rd argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rm */
  /* Processing variable eq */
    f2py_success = double_from_pyobj(&eq,eq_capi,"slalib.sla_amp() 4th argument (eq) can't be converted to double");
  if (f2py_success) {
  /* Processing variable da */
    f2py_success = double_from_pyobj(&da,da_capi,"slalib.sla_amp() 2nd argument (da) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ra,&da,&date,&eq,&rm,&dm);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",rm,dm);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of da*/
  /* End of cleaning variable da */
  } /*if (f2py_success) of eq*/
  /* End of cleaning variable eq */
  /* End of cleaning variable rm */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
  } /*if (f2py_success) of ra*/
  /* End of cleaning variable ra */
  /* End of cleaning variable dm */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_amp *******************************/

/********************************* sla_ampqk *********************************/
static char doc_f2py_rout_slalib_sla_ampqk[] = "\
Function signature:\n\
  rm,dm = sla_ampqk(ra,da,amprms)\n\
Required arguments:\n"
"  ra : input float\n"
"  da : input float\n"
"  amprms : input rank-1 array('d') with bounds (21)\n"
"Return objects:\n"
"  rm : float\n"
"  dm : float";
/* extern void F_FUNC_US(sla_ampqk,SLA_AMPQK)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_ampqk(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double ra = 0;
  PyObject *ra_capi = Py_None;
  double da = 0;
  PyObject *da_capi = Py_None;
  double *amprms = NULL;
  npy_intp amprms_Dims[1] = {-1};
  const int amprms_Rank = 1;
  PyArrayObject *capi_amprms_tmp = NULL;
  int capi_amprms_intent = 0;
  PyObject *amprms_capi = Py_None;
  double rm = 0;
  double dm = 0;
  static char *capi_kwlist[] = {"ra","da","amprms",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_ampqk",\
    capi_kwlist,&ra_capi,&da_capi,&amprms_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rm */
  /* Processing variable dm */
  /* Processing variable ra */
    f2py_success = double_from_pyobj(&ra,ra_capi,"slalib.sla_ampqk() 1st argument (ra) can't be converted to double");
  if (f2py_success) {
  /* Processing variable amprms */
  amprms_Dims[0]=21;
  capi_amprms_intent |= F2PY_INTENT_IN;
  capi_amprms_tmp = array_from_pyobj(PyArray_DOUBLE,amprms_Dims,amprms_Rank,capi_amprms_intent,amprms_capi);
  if (capi_amprms_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `amprms' of slalib.sla_ampqk to C/Fortran array" );
  } else {
    amprms = (double *)(capi_amprms_tmp->data);

  /* Processing variable da */
    f2py_success = double_from_pyobj(&da,da_capi,"slalib.sla_ampqk() 2nd argument (da) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ra,&da,amprms,&rm,&dm);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",rm,dm);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of da*/
  /* End of cleaning variable da */
  if((PyObject *)capi_amprms_tmp!=amprms_capi) {
    Py_XDECREF(capi_amprms_tmp); }
  }  /*if (capi_amprms_tmp == NULL) ... else of amprms*/
  /* End of cleaning variable amprms */
  } /*if (f2py_success) of ra*/
  /* End of cleaning variable ra */
  /* End of cleaning variable dm */
  /* End of cleaning variable rm */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_ampqk ******************************/

/********************************** sla_aop **********************************/
static char doc_f2py_rout_slalib_sla_aop[] = "\
Function signature:\n\
  aob,zob,hob,dob,rob = sla_aop(rap,dap,date,dut,elongm,phim,hm,xp,yp,tdk,pmb,rh,wl,tlr)\n\
Required arguments:\n"
"  rap : input float\n"
"  dap : input float\n"
"  date : input float\n"
"  dut : input float\n"
"  elongm : input float\n"
"  phim : input float\n"
"  hm : input float\n"
"  xp : input float\n"
"  yp : input float\n"
"  tdk : input float\n"
"  pmb : input float\n"
"  rh : input float\n"
"  wl : input float\n"
"  tlr : input float\n"
"Return objects:\n"
"  aob : float\n"
"  zob : float\n"
"  hob : float\n"
"  dob : float\n"
"  rob : float";
/* extern void F_FUNC_US(sla_aop,SLA_AOP)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_aop(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double rap = 0;
  PyObject *rap_capi = Py_None;
  double dap = 0;
  PyObject *dap_capi = Py_None;
  double date = 0;
  PyObject *date_capi = Py_None;
  double dut = 0;
  PyObject *dut_capi = Py_None;
  double elongm = 0;
  PyObject *elongm_capi = Py_None;
  double phim = 0;
  PyObject *phim_capi = Py_None;
  double hm = 0;
  PyObject *hm_capi = Py_None;
  double xp = 0;
  PyObject *xp_capi = Py_None;
  double yp = 0;
  PyObject *yp_capi = Py_None;
  double tdk = 0;
  PyObject *tdk_capi = Py_None;
  double pmb = 0;
  PyObject *pmb_capi = Py_None;
  double rh = 0;
  PyObject *rh_capi = Py_None;
  double wl = 0;
  PyObject *wl_capi = Py_None;
  double tlr = 0;
  PyObject *tlr_capi = Py_None;
  double aob = 0;
  double zob = 0;
  double hob = 0;
  double dob = 0;
  double rob = 0;
  static char *capi_kwlist[] = {"rap","dap","date","dut","elongm","phim","hm","xp","yp","tdk","pmb","rh","wl","tlr",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOOOOOOOO|:slalib.sla_aop",\
    capi_kwlist,&rap_capi,&dap_capi,&date_capi,&dut_capi,&elongm_capi,&phim_capi,&hm_capi,&xp_capi,&yp_capi,&tdk_capi,&pmb_capi,&rh_capi,&wl_capi,&tlr_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable tdk */
    f2py_success = double_from_pyobj(&tdk,tdk_capi,"slalib.sla_aop() 10th argument (tdk) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rap */
    f2py_success = double_from_pyobj(&rap,rap_capi,"slalib.sla_aop() 1st argument (rap) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rob */
  /* Processing variable wl */
    f2py_success = double_from_pyobj(&wl,wl_capi,"slalib.sla_aop() 13rd argument (wl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dap */
    f2py_success = double_from_pyobj(&dap,dap_capi,"slalib.sla_aop() 2nd argument (dap) can't be converted to double");
  if (f2py_success) {
  /* Processing variable pmb */
    f2py_success = double_from_pyobj(&pmb,pmb_capi,"slalib.sla_aop() 11st argument (pmb) can't be converted to double");
  if (f2py_success) {
  /* Processing variable hm */
    f2py_success = double_from_pyobj(&hm,hm_capi,"slalib.sla_aop() 7th argument (hm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_aop() 3rd argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable yp */
    f2py_success = double_from_pyobj(&yp,yp_capi,"slalib.sla_aop() 9th argument (yp) can't be converted to double");
  if (f2py_success) {
  /* Processing variable xp */
    f2py_success = double_from_pyobj(&xp,xp_capi,"slalib.sla_aop() 8th argument (xp) can't be converted to double");
  if (f2py_success) {
  /* Processing variable aob */
  /* Processing variable tlr */
    f2py_success = double_from_pyobj(&tlr,tlr_capi,"slalib.sla_aop() 14th argument (tlr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable zob */
  /* Processing variable hob */
  /* Processing variable dob */
  /* Processing variable dut */
    f2py_success = double_from_pyobj(&dut,dut_capi,"slalib.sla_aop() 4th argument (dut) can't be converted to double");
  if (f2py_success) {
  /* Processing variable phim */
    f2py_success = double_from_pyobj(&phim,phim_capi,"slalib.sla_aop() 6th argument (phim) can't be converted to double");
  if (f2py_success) {
  /* Processing variable elongm */
    f2py_success = double_from_pyobj(&elongm,elongm_capi,"slalib.sla_aop() 5th argument (elongm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rh */
    f2py_success = double_from_pyobj(&rh,rh_capi,"slalib.sla_aop() 12nd argument (rh) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&rap,&dap,&date,&dut,&elongm,&phim,&hm,&xp,&yp,&tdk,&pmb,&rh,&wl,&tlr,&aob,&zob,&hob,&dob,&rob);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ddddd",aob,zob,hob,dob,rob);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of rh*/
  /* End of cleaning variable rh */
  } /*if (f2py_success) of elongm*/
  /* End of cleaning variable elongm */
  } /*if (f2py_success) of phim*/
  /* End of cleaning variable phim */
  } /*if (f2py_success) of dut*/
  /* End of cleaning variable dut */
  /* End of cleaning variable dob */
  /* End of cleaning variable hob */
  /* End of cleaning variable zob */
  } /*if (f2py_success) of tlr*/
  /* End of cleaning variable tlr */
  /* End of cleaning variable aob */
  } /*if (f2py_success) of xp*/
  /* End of cleaning variable xp */
  } /*if (f2py_success) of yp*/
  /* End of cleaning variable yp */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
  } /*if (f2py_success) of hm*/
  /* End of cleaning variable hm */
  } /*if (f2py_success) of pmb*/
  /* End of cleaning variable pmb */
  } /*if (f2py_success) of dap*/
  /* End of cleaning variable dap */
  } /*if (f2py_success) of wl*/
  /* End of cleaning variable wl */
  /* End of cleaning variable rob */
  } /*if (f2py_success) of rap*/
  /* End of cleaning variable rap */
  } /*if (f2py_success) of tdk*/
  /* End of cleaning variable tdk */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_aop *******************************/

/********************************* sla_aoppa *********************************/
static char doc_f2py_rout_slalib_sla_aoppa[] = "\
Function signature:\n\
  aoprms = sla_aoppa(date,dut,elongm,phim,hm,xp,yp,tdk,pmb,rh,wl,tlr)\n\
Required arguments:\n"
"  date : input float\n"
"  dut : input float\n"
"  elongm : input float\n"
"  phim : input float\n"
"  hm : input float\n"
"  xp : input float\n"
"  yp : input float\n"
"  tdk : input float\n"
"  pmb : input float\n"
"  rh : input float\n"
"  wl : input float\n"
"  tlr : input float\n"
"Return objects:\n"
"  aoprms : rank-1 array('d') with bounds (14)";
/* extern void F_FUNC_US(sla_aoppa,SLA_AOPPA)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_aoppa(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double dut = 0;
  PyObject *dut_capi = Py_None;
  double elongm = 0;
  PyObject *elongm_capi = Py_None;
  double phim = 0;
  PyObject *phim_capi = Py_None;
  double hm = 0;
  PyObject *hm_capi = Py_None;
  double xp = 0;
  PyObject *xp_capi = Py_None;
  double yp = 0;
  PyObject *yp_capi = Py_None;
  double tdk = 0;
  PyObject *tdk_capi = Py_None;
  double pmb = 0;
  PyObject *pmb_capi = Py_None;
  double rh = 0;
  PyObject *rh_capi = Py_None;
  double wl = 0;
  PyObject *wl_capi = Py_None;
  double tlr = 0;
  PyObject *tlr_capi = Py_None;
  double *aoprms = NULL;
  npy_intp aoprms_Dims[1] = {-1};
  const int aoprms_Rank = 1;
  PyArrayObject *capi_aoprms_tmp = NULL;
  int capi_aoprms_intent = 0;
  static char *capi_kwlist[] = {"date","dut","elongm","phim","hm","xp","yp","tdk","pmb","rh","wl","tlr",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOOOOOO|:slalib.sla_aoppa",\
    capi_kwlist,&date_capi,&dut_capi,&elongm_capi,&phim_capi,&hm_capi,&xp_capi,&yp_capi,&tdk_capi,&pmb_capi,&rh_capi,&wl_capi,&tlr_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable tdk */
    f2py_success = double_from_pyobj(&tdk,tdk_capi,"slalib.sla_aoppa() 8th argument (tdk) can't be converted to double");
  if (f2py_success) {
  /* Processing variable tlr */
    f2py_success = double_from_pyobj(&tlr,tlr_capi,"slalib.sla_aoppa() 12nd argument (tlr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dut */
    f2py_success = double_from_pyobj(&dut,dut_capi,"slalib.sla_aoppa() 2nd argument (dut) can't be converted to double");
  if (f2py_success) {
  /* Processing variable phim */
    f2py_success = double_from_pyobj(&phim,phim_capi,"slalib.sla_aoppa() 4th argument (phim) can't be converted to double");
  if (f2py_success) {
  /* Processing variable wl */
    f2py_success = double_from_pyobj(&wl,wl_capi,"slalib.sla_aoppa() 11st argument (wl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable aoprms */
  aoprms_Dims[0]=14;
  capi_aoprms_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_aoprms_tmp = array_from_pyobj(PyArray_DOUBLE,aoprms_Dims,aoprms_Rank,capi_aoprms_intent,Py_None);
  if (capi_aoprms_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `aoprms' of slalib.sla_aoppa to C/Fortran array" );
  } else {
    aoprms = (double *)(capi_aoprms_tmp->data);

  /* Processing variable elongm */
    f2py_success = double_from_pyobj(&elongm,elongm_capi,"slalib.sla_aoppa() 3rd argument (elongm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable pmb */
    f2py_success = double_from_pyobj(&pmb,pmb_capi,"slalib.sla_aoppa() 9th argument (pmb) can't be converted to double");
  if (f2py_success) {
  /* Processing variable hm */
    f2py_success = double_from_pyobj(&hm,hm_capi,"slalib.sla_aoppa() 5th argument (hm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_aoppa() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable yp */
    f2py_success = double_from_pyobj(&yp,yp_capi,"slalib.sla_aoppa() 7th argument (yp) can't be converted to double");
  if (f2py_success) {
  /* Processing variable xp */
    f2py_success = double_from_pyobj(&xp,xp_capi,"slalib.sla_aoppa() 6th argument (xp) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rh */
    f2py_success = double_from_pyobj(&rh,rh_capi,"slalib.sla_aoppa() 10th argument (rh) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,&dut,&elongm,&phim,&hm,&xp,&yp,&tdk,&pmb,&rh,&wl,&tlr,aoprms);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_aoprms_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of rh*/
  /* End of cleaning variable rh */
  } /*if (f2py_success) of xp*/
  /* End of cleaning variable xp */
  } /*if (f2py_success) of yp*/
  /* End of cleaning variable yp */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
  } /*if (f2py_success) of hm*/
  /* End of cleaning variable hm */
  } /*if (f2py_success) of pmb*/
  /* End of cleaning variable pmb */
  } /*if (f2py_success) of elongm*/
  /* End of cleaning variable elongm */
  }  /*if (capi_aoprms_tmp == NULL) ... else of aoprms*/
  /* End of cleaning variable aoprms */
  } /*if (f2py_success) of wl*/
  /* End of cleaning variable wl */
  } /*if (f2py_success) of phim*/
  /* End of cleaning variable phim */
  } /*if (f2py_success) of dut*/
  /* End of cleaning variable dut */
  } /*if (f2py_success) of tlr*/
  /* End of cleaning variable tlr */
  } /*if (f2py_success) of tdk*/
  /* End of cleaning variable tdk */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_aoppa ******************************/

/********************************* sla_aoppat *********************************/
static char doc_f2py_rout_slalib_sla_aoppat[] = "\
Function signature:\n\
  aoprms = sla_aoppat(date,aoprms)\n\
Required arguments:\n"
"  date : input float\n"
"  aoprms : input rank-1 array('d') with bounds (14)\n"
"Return objects:\n"
"  aoprms : rank-1 array('d') with bounds (14)";
/* extern void F_FUNC_US(sla_aoppat,SLA_AOPPAT)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_aoppat(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double *aoprms = NULL;
  npy_intp aoprms_Dims[1] = {-1};
  const int aoprms_Rank = 1;
  PyArrayObject *capi_aoprms_tmp = NULL;
  int capi_aoprms_intent = 0;
  PyObject *aoprms_capi = Py_None;
  static char *capi_kwlist[] = {"date","aoprms",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_aoppat",\
    capi_kwlist,&date_capi,&aoprms_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_aoppat() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable aoprms */
  aoprms_Dims[0]=14;
  capi_aoprms_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_aoprms_tmp = array_from_pyobj(PyArray_DOUBLE,aoprms_Dims,aoprms_Rank,capi_aoprms_intent,aoprms_capi);
  if (capi_aoprms_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `aoprms' of slalib.sla_aoppat to C/Fortran array" );
  } else {
    aoprms = (double *)(capi_aoprms_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,aoprms);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_aoprms_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_aoprms_tmp == NULL) ... else of aoprms*/
  /* End of cleaning variable aoprms */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_aoppat *****************************/

/********************************* sla_aopqk *********************************/
static char doc_f2py_rout_slalib_sla_aopqk[] = "\
Function signature:\n\
  aob,zob,hob,dob,rob = sla_aopqk(rap,dap,aoprms)\n\
Required arguments:\n"
"  rap : input float\n"
"  dap : input float\n"
"  aoprms : input rank-1 array('d') with bounds (14)\n"
"Return objects:\n"
"  aob : float\n"
"  zob : float\n"
"  hob : float\n"
"  dob : float\n"
"  rob : float";
/* extern void F_FUNC_US(sla_aopqk,SLA_AOPQK)(double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_aopqk(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double rap = 0;
  PyObject *rap_capi = Py_None;
  double dap = 0;
  PyObject *dap_capi = Py_None;
  double *aoprms = NULL;
  npy_intp aoprms_Dims[1] = {-1};
  const int aoprms_Rank = 1;
  PyArrayObject *capi_aoprms_tmp = NULL;
  int capi_aoprms_intent = 0;
  PyObject *aoprms_capi = Py_None;
  double aob = 0;
  double zob = 0;
  double hob = 0;
  double dob = 0;
  double rob = 0;
  static char *capi_kwlist[] = {"rap","dap","aoprms",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_aopqk",\
    capi_kwlist,&rap_capi,&dap_capi,&aoprms_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable aoprms */
  aoprms_Dims[0]=14;
  capi_aoprms_intent |= F2PY_INTENT_IN;
  capi_aoprms_tmp = array_from_pyobj(PyArray_DOUBLE,aoprms_Dims,aoprms_Rank,capi_aoprms_intent,aoprms_capi);
  if (capi_aoprms_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `aoprms' of slalib.sla_aopqk to C/Fortran array" );
  } else {
    aoprms = (double *)(capi_aoprms_tmp->data);

  /* Processing variable zob */
  /* Processing variable hob */
  /* Processing variable aob */
  /* Processing variable dob */
  /* Processing variable rob */
  /* Processing variable dap */
    f2py_success = double_from_pyobj(&dap,dap_capi,"slalib.sla_aopqk() 2nd argument (dap) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rap */
    f2py_success = double_from_pyobj(&rap,rap_capi,"slalib.sla_aopqk() 1st argument (rap) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&rap,&dap,aoprms,&aob,&zob,&hob,&dob,&rob);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ddddd",aob,zob,hob,dob,rob);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of rap*/
  /* End of cleaning variable rap */
  } /*if (f2py_success) of dap*/
  /* End of cleaning variable dap */
  /* End of cleaning variable rob */
  /* End of cleaning variable dob */
  /* End of cleaning variable aob */
  /* End of cleaning variable hob */
  /* End of cleaning variable zob */
  if((PyObject *)capi_aoprms_tmp!=aoprms_capi) {
    Py_XDECREF(capi_aoprms_tmp); }
  }  /*if (capi_aoprms_tmp == NULL) ... else of aoprms*/
  /* End of cleaning variable aoprms */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_aopqk ******************************/

/********************************* sla_atmdsp *********************************/
static char doc_f2py_rout_slalib_sla_atmdsp[] = "\
Function signature:\n\
  a2,b2 = sla_atmdsp(tdk,pmb,rh,wl1,a1,b1,wl2)\n\
Required arguments:\n"
"  tdk : input float\n"
"  pmb : input float\n"
"  rh : input float\n"
"  wl1 : input float\n"
"  a1 : input float\n"
"  b1 : input float\n"
"  wl2 : input float\n"
"Return objects:\n"
"  a2 : float\n"
"  b2 : float";
/* extern void F_FUNC_US(sla_atmdsp,SLA_ATMDSP)(double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_atmdsp(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double tdk = 0;
  PyObject *tdk_capi = Py_None;
  double pmb = 0;
  PyObject *pmb_capi = Py_None;
  double rh = 0;
  PyObject *rh_capi = Py_None;
  double wl1 = 0;
  PyObject *wl1_capi = Py_None;
  double a1 = 0;
  PyObject *a1_capi = Py_None;
  double b1 = 0;
  PyObject *b1_capi = Py_None;
  double wl2 = 0;
  PyObject *wl2_capi = Py_None;
  double a2 = 0;
  double b2 = 0;
  static char *capi_kwlist[] = {"tdk","pmb","rh","wl1","a1","b1","wl2",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOO|:slalib.sla_atmdsp",\
    capi_kwlist,&tdk_capi,&pmb_capi,&rh_capi,&wl1_capi,&a1_capi,&b1_capi,&wl2_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable tdk */
    f2py_success = double_from_pyobj(&tdk,tdk_capi,"slalib.sla_atmdsp() 1st argument (tdk) can't be converted to double");
  if (f2py_success) {
  /* Processing variable pmb */
    f2py_success = double_from_pyobj(&pmb,pmb_capi,"slalib.sla_atmdsp() 2nd argument (pmb) can't be converted to double");
  if (f2py_success) {
  /* Processing variable wl1 */
    f2py_success = double_from_pyobj(&wl1,wl1_capi,"slalib.sla_atmdsp() 4th argument (wl1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable wl2 */
    f2py_success = double_from_pyobj(&wl2,wl2_capi,"slalib.sla_atmdsp() 7th argument (wl2) can't be converted to double");
  if (f2py_success) {
  /* Processing variable a1 */
    f2py_success = double_from_pyobj(&a1,a1_capi,"slalib.sla_atmdsp() 5th argument (a1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable a2 */
  /* Processing variable b1 */
    f2py_success = double_from_pyobj(&b1,b1_capi,"slalib.sla_atmdsp() 6th argument (b1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable b2 */
  /* Processing variable rh */
    f2py_success = double_from_pyobj(&rh,rh_capi,"slalib.sla_atmdsp() 3rd argument (rh) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&tdk,&pmb,&rh,&wl1,&a1,&b1,&wl2,&a2,&b2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",a2,b2);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of rh*/
  /* End of cleaning variable rh */
  /* End of cleaning variable b2 */
  } /*if (f2py_success) of b1*/
  /* End of cleaning variable b1 */
  /* End of cleaning variable a2 */
  } /*if (f2py_success) of a1*/
  /* End of cleaning variable a1 */
  } /*if (f2py_success) of wl2*/
  /* End of cleaning variable wl2 */
  } /*if (f2py_success) of wl1*/
  /* End of cleaning variable wl1 */
  } /*if (f2py_success) of pmb*/
  /* End of cleaning variable pmb */
  } /*if (f2py_success) of tdk*/
  /* End of cleaning variable tdk */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_atmdsp *****************************/

/********************************* sla__atms *********************************/
static char doc_f2py_rout_slalib_sla__atms[] = "\
Function signature:\n\
  sla__atms(rt,tt,dnt,gamal,r,dn,rdndr)\n\
Required arguments:\n"
"  rt : input float\n"
"  tt : input float\n"
"  dnt : input float\n"
"  gamal : input float\n"
"  r : input float\n"
"  dn : input float\n"
"  rdndr : input float";
/* extern void F_FUNC_US(sla__atms,SLA__ATMS)(double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla__atms(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double rt = 0;
  PyObject *rt_capi = Py_None;
  double tt = 0;
  PyObject *tt_capi = Py_None;
  double dnt = 0;
  PyObject *dnt_capi = Py_None;
  double gamal = 0;
  PyObject *gamal_capi = Py_None;
  double r = 0;
  PyObject *r_capi = Py_None;
  double dn = 0;
  PyObject *dn_capi = Py_None;
  double rdndr = 0;
  PyObject *rdndr_capi = Py_None;
  static char *capi_kwlist[] = {"rt","tt","dnt","gamal","r","dn","rdndr",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOO|:slalib.sla__atms",\
    capi_kwlist,&rt_capi,&tt_capi,&dnt_capi,&gamal_capi,&r_capi,&dn_capi,&rdndr_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rt */
    f2py_success = double_from_pyobj(&rt,rt_capi,"slalib.sla__atms() 1st argument (rt) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dn */
    f2py_success = double_from_pyobj(&dn,dn_capi,"slalib.sla__atms() 6th argument (dn) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rdndr */
    f2py_success = double_from_pyobj(&rdndr,rdndr_capi,"slalib.sla__atms() 7th argument (rdndr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dnt */
    f2py_success = double_from_pyobj(&dnt,dnt_capi,"slalib.sla__atms() 3rd argument (dnt) can't be converted to double");
  if (f2py_success) {
  /* Processing variable tt */
    f2py_success = double_from_pyobj(&tt,tt_capi,"slalib.sla__atms() 2nd argument (tt) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r */
    f2py_success = double_from_pyobj(&r,r_capi,"slalib.sla__atms() 5th argument (r) can't be converted to double");
  if (f2py_success) {
  /* Processing variable gamal */
    f2py_success = double_from_pyobj(&gamal,gamal_capi,"slalib.sla__atms() 4th argument (gamal) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&rt,&tt,&dnt,&gamal,&r,&dn,&rdndr);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("");
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of gamal*/
  /* End of cleaning variable gamal */
  } /*if (f2py_success) of r*/
  /* End of cleaning variable r */
  } /*if (f2py_success) of tt*/
  /* End of cleaning variable tt */
  } /*if (f2py_success) of dnt*/
  /* End of cleaning variable dnt */
  } /*if (f2py_success) of rdndr*/
  /* End of cleaning variable rdndr */
  } /*if (f2py_success) of dn*/
  /* End of cleaning variable dn */
  } /*if (f2py_success) of rt*/
  /* End of cleaning variable rt */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla__atms ******************************/

/********************************* sla__atmt *********************************/
static char doc_f2py_rout_slalib_sla__atmt[] = "\
Function signature:\n\
  sla__atmt(r0,t0,alpha,gamm2,delm2,c1,c2,c3,c4,c5,c6,r,t,dn,rdndr)\n\
Required arguments:\n"
"  r0 : input float\n"
"  t0 : input float\n"
"  alpha : input float\n"
"  gamm2 : input float\n"
"  delm2 : input float\n"
"  c1 : input float\n"
"  c2 : input float\n"
"  c3 : input float\n"
"  c4 : input float\n"
"  c5 : input float\n"
"  c6 : input float\n"
"  r : input float\n"
"  t : input float\n"
"  dn : input float\n"
"  rdndr : input float";
/* extern void F_FUNC_US(sla__atmt,SLA__ATMT)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla__atmt(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double r0 = 0;
  PyObject *r0_capi = Py_None;
  double t0 = 0;
  PyObject *t0_capi = Py_None;
  double alpha = 0;
  PyObject *alpha_capi = Py_None;
  double gamm2 = 0;
  PyObject *gamm2_capi = Py_None;
  double delm2 = 0;
  PyObject *delm2_capi = Py_None;
  double c1 = 0;
  PyObject *c1_capi = Py_None;
  double c2 = 0;
  PyObject *c2_capi = Py_None;
  double c3 = 0;
  PyObject *c3_capi = Py_None;
  double c4 = 0;
  PyObject *c4_capi = Py_None;
  double c5 = 0;
  PyObject *c5_capi = Py_None;
  double c6 = 0;
  PyObject *c6_capi = Py_None;
  double r = 0;
  PyObject *r_capi = Py_None;
  double t = 0;
  PyObject *t_capi = Py_None;
  double dn = 0;
  PyObject *dn_capi = Py_None;
  double rdndr = 0;
  PyObject *rdndr_capi = Py_None;
  static char *capi_kwlist[] = {"r0","t0","alpha","gamm2","delm2","c1","c2","c3","c4","c5","c6","r","t","dn","rdndr",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOOOOOOOOO|:slalib.sla__atmt",\
    capi_kwlist,&r0_capi,&t0_capi,&alpha_capi,&gamm2_capi,&delm2_capi,&c1_capi,&c2_capi,&c3_capi,&c4_capi,&c5_capi,&c6_capi,&r_capi,&t_capi,&dn_capi,&rdndr_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dn */
    f2py_success = double_from_pyobj(&dn,dn_capi,"slalib.sla__atmt() 14th argument (dn) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r0 */
    f2py_success = double_from_pyobj(&r0,r0_capi,"slalib.sla__atmt() 1st argument (r0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable gamm2 */
    f2py_success = double_from_pyobj(&gamm2,gamm2_capi,"slalib.sla__atmt() 4th argument (gamm2) can't be converted to double");
  if (f2py_success) {
  /* Processing variable t0 */
    f2py_success = double_from_pyobj(&t0,t0_capi,"slalib.sla__atmt() 2nd argument (t0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable delm2 */
    f2py_success = double_from_pyobj(&delm2,delm2_capi,"slalib.sla__atmt() 5th argument (delm2) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rdndr */
    f2py_success = double_from_pyobj(&rdndr,rdndr_capi,"slalib.sla__atmt() 15th argument (rdndr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable t */
    f2py_success = double_from_pyobj(&t,t_capi,"slalib.sla__atmt() 13rd argument (t) can't be converted to double");
  if (f2py_success) {
  /* Processing variable alpha */
    f2py_success = double_from_pyobj(&alpha,alpha_capi,"slalib.sla__atmt() 3rd argument (alpha) can't be converted to double");
  if (f2py_success) {
  /* Processing variable c3 */
    f2py_success = double_from_pyobj(&c3,c3_capi,"slalib.sla__atmt() 8th argument (c3) can't be converted to double");
  if (f2py_success) {
  /* Processing variable c2 */
    f2py_success = double_from_pyobj(&c2,c2_capi,"slalib.sla__atmt() 7th argument (c2) can't be converted to double");
  if (f2py_success) {
  /* Processing variable c1 */
    f2py_success = double_from_pyobj(&c1,c1_capi,"slalib.sla__atmt() 6th argument (c1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r */
    f2py_success = double_from_pyobj(&r,r_capi,"slalib.sla__atmt() 12nd argument (r) can't be converted to double");
  if (f2py_success) {
  /* Processing variable c6 */
    f2py_success = double_from_pyobj(&c6,c6_capi,"slalib.sla__atmt() 11st argument (c6) can't be converted to double");
  if (f2py_success) {
  /* Processing variable c5 */
    f2py_success = double_from_pyobj(&c5,c5_capi,"slalib.sla__atmt() 10th argument (c5) can't be converted to double");
  if (f2py_success) {
  /* Processing variable c4 */
    f2py_success = double_from_pyobj(&c4,c4_capi,"slalib.sla__atmt() 9th argument (c4) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&r0,&t0,&alpha,&gamm2,&delm2,&c1,&c2,&c3,&c4,&c5,&c6,&r,&t,&dn,&rdndr);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("");
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of c4*/
  /* End of cleaning variable c4 */
  } /*if (f2py_success) of c5*/
  /* End of cleaning variable c5 */
  } /*if (f2py_success) of c6*/
  /* End of cleaning variable c6 */
  } /*if (f2py_success) of r*/
  /* End of cleaning variable r */
  } /*if (f2py_success) of c1*/
  /* End of cleaning variable c1 */
  } /*if (f2py_success) of c2*/
  /* End of cleaning variable c2 */
  } /*if (f2py_success) of c3*/
  /* End of cleaning variable c3 */
  } /*if (f2py_success) of alpha*/
  /* End of cleaning variable alpha */
  } /*if (f2py_success) of t*/
  /* End of cleaning variable t */
  } /*if (f2py_success) of rdndr*/
  /* End of cleaning variable rdndr */
  } /*if (f2py_success) of delm2*/
  /* End of cleaning variable delm2 */
  } /*if (f2py_success) of t0*/
  /* End of cleaning variable t0 */
  } /*if (f2py_success) of gamm2*/
  /* End of cleaning variable gamm2 */
  } /*if (f2py_success) of r0*/
  /* End of cleaning variable r0 */
  } /*if (f2py_success) of dn*/
  /* End of cleaning variable dn */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla__atmt ******************************/

/********************************** sla_av2m **********************************/
static char doc_f2py_rout_slalib_sla_av2m[] = "\
Function signature:\n\
  rmat = sla_av2m(axvec)\n\
Required arguments:\n"
"  axvec : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  rmat : rank-2 array('f') with bounds (3,3)";
/* extern void F_FUNC_US(sla_av2m,SLA_AV2M)(float*,float*); */
static PyObject *f2py_rout_slalib_sla_av2m(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float *axvec = NULL;
  npy_intp axvec_Dims[1] = {-1};
  const int axvec_Rank = 1;
  PyArrayObject *capi_axvec_tmp = NULL;
  int capi_axvec_intent = 0;
  PyObject *axvec_capi = Py_None;
  float *rmat = NULL;
  npy_intp rmat_Dims[2] = {-1, -1};
  const int rmat_Rank = 2;
  PyArrayObject *capi_rmat_tmp = NULL;
  int capi_rmat_intent = 0;
  static char *capi_kwlist[] = {"axvec",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_av2m",\
    capi_kwlist,&axvec_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rmat */
  rmat_Dims[0]=3,rmat_Dims[1]=3;
  capi_rmat_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_rmat_tmp = array_from_pyobj(PyArray_FLOAT,rmat_Dims,rmat_Rank,capi_rmat_intent,Py_None);
  if (capi_rmat_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `rmat' of slalib.sla_av2m to C/Fortran array" );
  } else {
    rmat = (float *)(capi_rmat_tmp->data);

  /* Processing variable axvec */
  axvec_Dims[0]=3;
  capi_axvec_intent |= F2PY_INTENT_IN;
  capi_axvec_tmp = array_from_pyobj(PyArray_FLOAT,axvec_Dims,axvec_Rank,capi_axvec_intent,axvec_capi);
  if (capi_axvec_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `axvec' of slalib.sla_av2m to C/Fortran array" );
  } else {
    axvec = (float *)(capi_axvec_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(axvec,rmat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_rmat_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_axvec_tmp!=axvec_capi) {
    Py_XDECREF(capi_axvec_tmp); }
  }  /*if (capi_axvec_tmp == NULL) ... else of axvec*/
  /* End of cleaning variable axvec */
  }  /*if (capi_rmat_tmp == NULL) ... else of rmat*/
  /* End of cleaning variable rmat */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_av2m ******************************/

/********************************** sla_bear **********************************/
static char doc_f2py_rout_slalib_sla_bear[] = "\
Function signature:\n\
  sla_bear = sla_bear(a1,b1,a2,b2)\n\
Required arguments:\n"
"  a1 : input float\n"
"  b1 : input float\n"
"  a2 : input float\n"
"  b2 : input float\n"
"Return objects:\n"
"  sla_bear : float";
/* extern void F_WRAPPEDFUNC_US(sla_bear,SLA_BEAR)(float*,float*,float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_bear(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_bear = 0;
  float a1 = 0;
  PyObject *a1_capi = Py_None;
  float b1 = 0;
  PyObject *b1_capi = Py_None;
  float a2 = 0;
  PyObject *a2_capi = Py_None;
  float b2 = 0;
  PyObject *b2_capi = Py_None;
  static char *capi_kwlist[] = {"a1","b1","a2","b2",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_bear",\
    capi_kwlist,&a1_capi,&b1_capi,&a2_capi,&b2_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a1 */
    f2py_success = float_from_pyobj(&a1,a1_capi,"slalib.sla_bear() 1st argument (a1) can't be converted to float");
  if (f2py_success) {
  /* Processing variable a2 */
    f2py_success = float_from_pyobj(&a2,a2_capi,"slalib.sla_bear() 3rd argument (a2) can't be converted to float");
  if (f2py_success) {
  /* Processing variable b1 */
    f2py_success = float_from_pyobj(&b1,b1_capi,"slalib.sla_bear() 2nd argument (b1) can't be converted to float");
  if (f2py_success) {
  /* Processing variable b2 */
    f2py_success = float_from_pyobj(&b2,b2_capi,"slalib.sla_bear() 4th argument (b2) can't be converted to float");
  if (f2py_success) {
  /* Processing variable sla_bear */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_bear,&a1,&b1,&a2,&b2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_bear);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_bear */
  } /*if (f2py_success) of b2*/
  /* End of cleaning variable b2 */
  } /*if (f2py_success) of b1*/
  /* End of cleaning variable b1 */
  } /*if (f2py_success) of a2*/
  /* End of cleaning variable a2 */
  } /*if (f2py_success) of a1*/
  /* End of cleaning variable a1 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_bear ******************************/

/********************************* sla_caf2r *********************************/
static char doc_f2py_rout_slalib_sla_caf2r[] = "\
Function signature:\n\
  rad,j = sla_caf2r(ideg,iamin,asec)\n\
Required arguments:\n"
"  ideg : input int\n"
"  iamin : input int\n"
"  asec : input float\n"
"Return objects:\n"
"  rad : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_caf2r,SLA_CAF2R)(int*,int*,float*,float*,int*); */
static PyObject *f2py_rout_slalib_sla_caf2r(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,float*,float*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ideg = 0;
  PyObject *ideg_capi = Py_None;
  int iamin = 0;
  PyObject *iamin_capi = Py_None;
  float asec = 0;
  PyObject *asec_capi = Py_None;
  float rad = 0;
  int j = 0;
  static char *capi_kwlist[] = {"ideg","iamin","asec",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_caf2r",\
    capi_kwlist,&ideg_capi,&iamin_capi,&asec_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable asec */
    f2py_success = float_from_pyobj(&asec,asec_capi,"slalib.sla_caf2r() 3rd argument (asec) can't be converted to float");
  if (f2py_success) {
  /* Processing variable rad */
  /* Processing variable ideg */
    f2py_success = int_from_pyobj(&ideg,ideg_capi,"slalib.sla_caf2r() 1st argument (ideg) can't be converted to int");
  if (f2py_success) {
  /* Processing variable iamin */
    f2py_success = int_from_pyobj(&iamin,iamin_capi,"slalib.sla_caf2r() 2nd argument (iamin) can't be converted to int");
  if (f2py_success) {
  /* Processing variable j */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ideg,&iamin,&asec,&rad,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("fi",rad,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable j */
  } /*if (f2py_success) of iamin*/
  /* End of cleaning variable iamin */
  } /*if (f2py_success) of ideg*/
  /* End of cleaning variable ideg */
  /* End of cleaning variable rad */
  } /*if (f2py_success) of asec*/
  /* End of cleaning variable asec */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_caf2r ******************************/

/********************************* sla_caldj *********************************/
static char doc_f2py_rout_slalib_sla_caldj[] = "\
Function signature:\n\
  djm,j = sla_caldj(iy,im,id)\n\
Required arguments:\n"
"  iy : input int\n"
"  im : input int\n"
"  id : input int\n"
"Return objects:\n"
"  djm : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_caldj,SLA_CALDJ)(int*,int*,int*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_caldj(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,int*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int iy = 0;
  PyObject *iy_capi = Py_None;
  int im = 0;
  PyObject *im_capi = Py_None;
  int id = 0;
  PyObject *id_capi = Py_None;
  double djm = 0;
  int j = 0;
  static char *capi_kwlist[] = {"iy","im","id",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_caldj",\
    capi_kwlist,&iy_capi,&im_capi,&id_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable iy */
    f2py_success = int_from_pyobj(&iy,iy_capi,"slalib.sla_caldj() 1st argument (iy) can't be converted to int");
  if (f2py_success) {
  /* Processing variable im */
    f2py_success = int_from_pyobj(&im,im_capi,"slalib.sla_caldj() 2nd argument (im) can't be converted to int");
  if (f2py_success) {
  /* Processing variable j */
  /* Processing variable djm */
  /* Processing variable id */
    f2py_success = int_from_pyobj(&id,id_capi,"slalib.sla_caldj() 3rd argument (id) can't be converted to int");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&iy,&im,&id,&djm,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("di",djm,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of id*/
  /* End of cleaning variable id */
  /* End of cleaning variable djm */
  /* End of cleaning variable j */
  } /*if (f2py_success) of im*/
  /* End of cleaning variable im */
  } /*if (f2py_success) of iy*/
  /* End of cleaning variable iy */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_caldj ******************************/

/********************************* sla_calyd *********************************/
static char doc_f2py_rout_slalib_sla_calyd[] = "\
Function signature:\n\
  ny,nd,j = sla_calyd(iy,im,id)\n\
Required arguments:\n"
"  iy : input int\n"
"  im : input int\n"
"  id : input int\n"
"Return objects:\n"
"  ny : int\n"
"  nd : int\n"
"  j : int";
/* extern void F_FUNC_US(sla_calyd,SLA_CALYD)(int*,int*,int*,int*,int*,int*); */
static PyObject *f2py_rout_slalib_sla_calyd(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,int*,int*,int*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int iy = 0;
  PyObject *iy_capi = Py_None;
  int im = 0;
  PyObject *im_capi = Py_None;
  int id = 0;
  PyObject *id_capi = Py_None;
  int ny = 0;
  int nd = 0;
  int j = 0;
  static char *capi_kwlist[] = {"iy","im","id",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_calyd",\
    capi_kwlist,&iy_capi,&im_capi,&id_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable iy */
    f2py_success = int_from_pyobj(&iy,iy_capi,"slalib.sla_calyd() 1st argument (iy) can't be converted to int");
  if (f2py_success) {
  /* Processing variable ny */
  /* Processing variable im */
    f2py_success = int_from_pyobj(&im,im_capi,"slalib.sla_calyd() 2nd argument (im) can't be converted to int");
  if (f2py_success) {
  /* Processing variable j */
  /* Processing variable nd */
  /* Processing variable id */
    f2py_success = int_from_pyobj(&id,id_capi,"slalib.sla_calyd() 3rd argument (id) can't be converted to int");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&iy,&im,&id,&ny,&nd,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("iii",ny,nd,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of id*/
  /* End of cleaning variable id */
  /* End of cleaning variable nd */
  /* End of cleaning variable j */
  } /*if (f2py_success) of im*/
  /* End of cleaning variable im */
  /* End of cleaning variable ny */
  } /*if (f2py_success) of iy*/
  /* End of cleaning variable iy */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_calyd ******************************/

/********************************** sla_cc2s **********************************/
static char doc_f2py_rout_slalib_sla_cc2s[] = "\
Function signature:\n\
  a,b = sla_cc2s(v)\n\
Required arguments:\n"
"  v : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  a : float\n"
"  b : float";
/* extern void F_FUNC_US(sla_cc2s,SLA_CC2S)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_cc2s(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  float a = 0;
  float b = 0;
  static char *capi_kwlist[] = {"v",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_cc2s",\
    capi_kwlist,&v_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
  /* Processing variable b */
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_FLOAT,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v' of slalib.sla_cc2s to C/Fortran array" );
  } else {
    v = (float *)(capi_v_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(v,&a,&b);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ff",a,b);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  /* End of cleaning variable b */
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_cc2s ******************************/

/********************************* sla_cc62s *********************************/
static char doc_f2py_rout_slalib_sla_cc62s[] = "\
Function signature:\n\
  a,b,r,ad,bd,rd = sla_cc62s(v)\n\
Required arguments:\n"
"  v : input rank-1 array('f') with bounds (6)\n"
"Return objects:\n"
"  a : float\n"
"  b : float\n"
"  r : float\n"
"  ad : float\n"
"  bd : float\n"
"  rd : float";
/* extern void F_FUNC_US(sla_cc62s,SLA_CC62S)(float*,float*,float*,float*,float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_cc62s(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  float a = 0;
  float b = 0;
  float r = 0;
  float ad = 0;
  float bd = 0;
  float rd = 0;
  static char *capi_kwlist[] = {"v",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_cc62s",\
    capi_kwlist,&v_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
  /* Processing variable bd */
  /* Processing variable r */
  /* Processing variable b */
  /* Processing variable ad */
  /* Processing variable v */
  v_Dims[0]=6;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_FLOAT,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v' of slalib.sla_cc62s to C/Fortran array" );
  } else {
    v = (float *)(capi_v_tmp->data);

  /* Processing variable rd */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(v,&a,&b,&r,&ad,&bd,&rd);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ffffff",a,b,r,ad,bd,rd);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable rd */
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  /* End of cleaning variable ad */
  /* End of cleaning variable b */
  /* End of cleaning variable r */
  /* End of cleaning variable bd */
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_cc62s ******************************/

/********************************* sla_cd2tf *********************************/
static char doc_f2py_rout_slalib_sla_cd2tf[] = "\
Function signature:\n\
  sign,ihmsf = sla_cd2tf(ndp,days)\n\
Required arguments:\n"
"  ndp : input int\n"
"  days : input float\n"
"Return objects:\n"
"  sign : string(len=1)\n"
"  ihmsf : rank-1 array('i') with bounds (4)";
/* extern void F_FUNC_US(sla_cd2tf,SLA_CD2TF)(int*,float*,string,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_cd2tf(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,float*,string,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ndp = 0;
  PyObject *ndp_capi = Py_None;
  float days = 0;
  PyObject *days_capi = Py_None;
  string sign = NULL;
  int slen(sign);
  PyObject *sign_capi = Py_None;
  int *ihmsf = NULL;
  npy_intp ihmsf_Dims[1] = {-1};
  const int ihmsf_Rank = 1;
  PyArrayObject *capi_ihmsf_tmp = NULL;
  int capi_ihmsf_intent = 0;
  static char *capi_kwlist[] = {"ndp","days",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_cd2tf",\
    capi_kwlist,&ndp_capi,&days_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ndp */
    f2py_success = int_from_pyobj(&ndp,ndp_capi,"slalib.sla_cd2tf() 1st argument (ndp) can't be converted to int");
  if (f2py_success) {
  /* Processing variable days */
    f2py_success = float_from_pyobj(&days,days_capi,"slalib.sla_cd2tf() 2nd argument (days) can't be converted to float");
  if (f2py_success) {
  /* Processing variable ihmsf */
  ihmsf_Dims[0]=4;
  capi_ihmsf_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_ihmsf_tmp = array_from_pyobj(PyArray_INT,ihmsf_Dims,ihmsf_Rank,capi_ihmsf_intent,Py_None);
  if (capi_ihmsf_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `ihmsf' of slalib.sla_cd2tf to C/Fortran array" );
  } else {
    ihmsf = (int *)(capi_ihmsf_tmp->data);

  /* Processing variable sign */
  slen(sign) = 1;
  f2py_success = string_from_pyobj(&sign,&slen(sign),"",sign_capi,"string_from_pyobj failed in converting hidden `sign' of slalib.sla_cd2tf to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ndp,&days,sign,ihmsf,slen(sign));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("zN",sign,capi_ihmsf_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(sign);
  }  /*if (f2py_success) of sign*/
  /* End of cleaning variable sign */
  }  /*if (capi_ihmsf_tmp == NULL) ... else of ihmsf*/
  /* End of cleaning variable ihmsf */
  } /*if (f2py_success) of days*/
  /* End of cleaning variable days */
  } /*if (f2py_success) of ndp*/
  /* End of cleaning variable ndp */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_cd2tf ******************************/

/********************************** sla_cldj **********************************/
static char doc_f2py_rout_slalib_sla_cldj[] = "\
Function signature:\n\
  djm,j = sla_cldj(iy,im,id)\n\
Required arguments:\n"
"  iy : input int\n"
"  im : input int\n"
"  id : input int\n"
"Return objects:\n"
"  djm : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_cldj,SLA_CLDJ)(int*,int*,int*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_cldj(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,int*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int iy = 0;
  PyObject *iy_capi = Py_None;
  int im = 0;
  PyObject *im_capi = Py_None;
  int id = 0;
  PyObject *id_capi = Py_None;
  double djm = 0;
  int j = 0;
  static char *capi_kwlist[] = {"iy","im","id",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_cldj",\
    capi_kwlist,&iy_capi,&im_capi,&id_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable iy */
    f2py_success = int_from_pyobj(&iy,iy_capi,"slalib.sla_cldj() 1st argument (iy) can't be converted to int");
  if (f2py_success) {
  /* Processing variable im */
    f2py_success = int_from_pyobj(&im,im_capi,"slalib.sla_cldj() 2nd argument (im) can't be converted to int");
  if (f2py_success) {
  /* Processing variable j */
  /* Processing variable djm */
  /* Processing variable id */
    f2py_success = int_from_pyobj(&id,id_capi,"slalib.sla_cldj() 3rd argument (id) can't be converted to int");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&iy,&im,&id,&djm,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("di",djm,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of id*/
  /* End of cleaning variable id */
  /* End of cleaning variable djm */
  /* End of cleaning variable j */
  } /*if (f2py_success) of im*/
  /* End of cleaning variable im */
  } /*if (f2py_success) of iy*/
  /* End of cleaning variable iy */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_cldj ******************************/

/********************************** sla_clyd **********************************/
static char doc_f2py_rout_slalib_sla_clyd[] = "\
Function signature:\n\
  ny,nd,jstat = sla_clyd(iy,im,id)\n\
Required arguments:\n"
"  iy : input int\n"
"  im : input int\n"
"  id : input int\n"
"Return objects:\n"
"  ny : int\n"
"  nd : int\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_clyd,SLA_CLYD)(int*,int*,int*,int*,int*,int*); */
static PyObject *f2py_rout_slalib_sla_clyd(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,int*,int*,int*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int iy = 0;
  PyObject *iy_capi = Py_None;
  int im = 0;
  PyObject *im_capi = Py_None;
  int id = 0;
  PyObject *id_capi = Py_None;
  int ny = 0;
  int nd = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"iy","im","id",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_clyd",\
    capi_kwlist,&iy_capi,&im_capi,&id_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable iy */
    f2py_success = int_from_pyobj(&iy,iy_capi,"slalib.sla_clyd() 1st argument (iy) can't be converted to int");
  if (f2py_success) {
  /* Processing variable ny */
  /* Processing variable im */
    f2py_success = int_from_pyobj(&im,im_capi,"slalib.sla_clyd() 2nd argument (im) can't be converted to int");
  if (f2py_success) {
  /* Processing variable jstat */
  /* Processing variable nd */
  /* Processing variable id */
    f2py_success = int_from_pyobj(&id,id_capi,"slalib.sla_clyd() 3rd argument (id) can't be converted to int");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&iy,&im,&id,&ny,&nd,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("iii",ny,nd,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of id*/
  /* End of cleaning variable id */
  /* End of cleaning variable nd */
  /* End of cleaning variable jstat */
  } /*if (f2py_success) of im*/
  /* End of cleaning variable im */
  /* End of cleaning variable ny */
  } /*if (f2py_success) of iy*/
  /* End of cleaning variable iy */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_clyd ******************************/

/********************************* sla_combn *********************************/
static char doc_f2py_rout_slalib_sla_combn[] = "\
Function signature:\n\
  list,j = sla_combn(ncand,list,[nsel])\n\
Required arguments:\n"
"  ncand : input int\n"
"  list : input rank-1 array('i') with bounds (nsel)\n"
"Optional arguments:\n"
"  nsel := len(list) input int\n"
"Return objects:\n"
"  list : rank-1 array('i') with bounds (nsel)\n"
"  j : int";
/* extern void F_FUNC_US(sla_combn,SLA_COMBN)(int*,int*,int*,int*); */
static PyObject *f2py_rout_slalib_sla_combn(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,int*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int nsel = 0;
  PyObject *nsel_capi = Py_None;
  int ncand = 0;
  PyObject *ncand_capi = Py_None;
  int *list = NULL;
  npy_intp list_Dims[1] = {-1};
  const int list_Rank = 1;
  PyArrayObject *capi_list_tmp = NULL;
  int capi_list_intent = 0;
  PyObject *list_capi = Py_None;
  int j = 0;
  static char *capi_kwlist[] = {"ncand","list","nsel",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|O:slalib.sla_combn",\
    capi_kwlist,&ncand_capi,&list_capi,&nsel_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ncand */
    f2py_success = int_from_pyobj(&ncand,ncand_capi,"slalib.sla_combn() 1st argument (ncand) can't be converted to int");
  if (f2py_success) {
  /* Processing variable j */
  /* Processing variable list */
  ;
  capi_list_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_list_tmp = array_from_pyobj(PyArray_INT,list_Dims,list_Rank,capi_list_intent,list_capi);
  if (capi_list_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `list' of slalib.sla_combn to C/Fortran array" );
  } else {
    list = (int *)(capi_list_tmp->data);

  /* Processing variable nsel */
  if (nsel_capi == Py_None) nsel = len(list); else
    f2py_success = int_from_pyobj(&nsel,nsel_capi,"slalib.sla_combn() 1st keyword (nsel) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(len(list)>=nsel,"len(list)>=nsel","1st keyword nsel","sla_combn:nsel=%d",nsel) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&nsel,&ncand,list,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Ni",capi_list_tmp,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*CHECKSCALAR(len(list)>=nsel)*/
  } /*if (f2py_success) of nsel*/
  /* End of cleaning variable nsel */
  }  /*if (capi_list_tmp == NULL) ... else of list*/
  /* End of cleaning variable list */
  /* End of cleaning variable j */
  } /*if (f2py_success) of ncand*/
  /* End of cleaning variable ncand */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_combn ******************************/

/********************************* sla_cr2af *********************************/
static char doc_f2py_rout_slalib_sla_cr2af[] = "\
Function signature:\n\
  sign,idmsf = sla_cr2af(ndp,angle)\n\
Required arguments:\n"
"  ndp : input int\n"
"  angle : input float\n"
"Return objects:\n"
"  sign : string(len=1)\n"
"  idmsf : rank-1 array('i') with bounds (4)";
/* extern void F_FUNC_US(sla_cr2af,SLA_CR2AF)(int*,float*,string,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_cr2af(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,float*,string,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ndp = 0;
  PyObject *ndp_capi = Py_None;
  float angle = 0;
  PyObject *angle_capi = Py_None;
  string sign = NULL;
  int slen(sign);
  PyObject *sign_capi = Py_None;
  int *idmsf = NULL;
  npy_intp idmsf_Dims[1] = {-1};
  const int idmsf_Rank = 1;
  PyArrayObject *capi_idmsf_tmp = NULL;
  int capi_idmsf_intent = 0;
  static char *capi_kwlist[] = {"ndp","angle",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_cr2af",\
    capi_kwlist,&ndp_capi,&angle_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ndp */
    f2py_success = int_from_pyobj(&ndp,ndp_capi,"slalib.sla_cr2af() 1st argument (ndp) can't be converted to int");
  if (f2py_success) {
  /* Processing variable idmsf */
  idmsf_Dims[0]=4;
  capi_idmsf_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_idmsf_tmp = array_from_pyobj(PyArray_INT,idmsf_Dims,idmsf_Rank,capi_idmsf_intent,Py_None);
  if (capi_idmsf_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `idmsf' of slalib.sla_cr2af to C/Fortran array" );
  } else {
    idmsf = (int *)(capi_idmsf_tmp->data);

  /* Processing variable angle */
    f2py_success = float_from_pyobj(&angle,angle_capi,"slalib.sla_cr2af() 2nd argument (angle) can't be converted to float");
  if (f2py_success) {
  /* Processing variable sign */
  slen(sign) = 1;
  f2py_success = string_from_pyobj(&sign,&slen(sign),"",sign_capi,"string_from_pyobj failed in converting hidden `sign' of slalib.sla_cr2af to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ndp,&angle,sign,idmsf,slen(sign));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("zN",sign,capi_idmsf_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(sign);
  }  /*if (f2py_success) of sign*/
  /* End of cleaning variable sign */
  } /*if (f2py_success) of angle*/
  /* End of cleaning variable angle */
  }  /*if (capi_idmsf_tmp == NULL) ... else of idmsf*/
  /* End of cleaning variable idmsf */
  } /*if (f2py_success) of ndp*/
  /* End of cleaning variable ndp */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_cr2af ******************************/

/********************************* sla_cr2tf *********************************/
static char doc_f2py_rout_slalib_sla_cr2tf[] = "\
Function signature:\n\
  sign,ihmsf = sla_cr2tf(ndp,angle)\n\
Required arguments:\n"
"  ndp : input int\n"
"  angle : input float\n"
"Return objects:\n"
"  sign : string(len=1)\n"
"  ihmsf : rank-1 array('i') with bounds (4)";
/* extern void F_FUNC_US(sla_cr2tf,SLA_CR2TF)(int*,float*,string,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_cr2tf(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,float*,string,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ndp = 0;
  PyObject *ndp_capi = Py_None;
  float angle = 0;
  PyObject *angle_capi = Py_None;
  string sign = NULL;
  int slen(sign);
  PyObject *sign_capi = Py_None;
  int *ihmsf = NULL;
  npy_intp ihmsf_Dims[1] = {-1};
  const int ihmsf_Rank = 1;
  PyArrayObject *capi_ihmsf_tmp = NULL;
  int capi_ihmsf_intent = 0;
  static char *capi_kwlist[] = {"ndp","angle",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_cr2tf",\
    capi_kwlist,&ndp_capi,&angle_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ndp */
    f2py_success = int_from_pyobj(&ndp,ndp_capi,"slalib.sla_cr2tf() 1st argument (ndp) can't be converted to int");
  if (f2py_success) {
  /* Processing variable angle */
    f2py_success = float_from_pyobj(&angle,angle_capi,"slalib.sla_cr2tf() 2nd argument (angle) can't be converted to float");
  if (f2py_success) {
  /* Processing variable ihmsf */
  ihmsf_Dims[0]=4;
  capi_ihmsf_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_ihmsf_tmp = array_from_pyobj(PyArray_INT,ihmsf_Dims,ihmsf_Rank,capi_ihmsf_intent,Py_None);
  if (capi_ihmsf_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `ihmsf' of slalib.sla_cr2tf to C/Fortran array" );
  } else {
    ihmsf = (int *)(capi_ihmsf_tmp->data);

  /* Processing variable sign */
  slen(sign) = 1;
  f2py_success = string_from_pyobj(&sign,&slen(sign),"",sign_capi,"string_from_pyobj failed in converting hidden `sign' of slalib.sla_cr2tf to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ndp,&angle,sign,ihmsf,slen(sign));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("zN",sign,capi_ihmsf_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(sign);
  }  /*if (f2py_success) of sign*/
  /* End of cleaning variable sign */
  }  /*if (capi_ihmsf_tmp == NULL) ... else of ihmsf*/
  /* End of cleaning variable ihmsf */
  } /*if (f2py_success) of angle*/
  /* End of cleaning variable angle */
  } /*if (f2py_success) of ndp*/
  /* End of cleaning variable ndp */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_cr2tf ******************************/

/********************************* sla_cs2c6 *********************************/
static char doc_f2py_rout_slalib_sla_cs2c6[] = "\
Function signature:\n\
  v = sla_cs2c6(a,b,r,ad,bd,rd)\n\
Required arguments:\n"
"  a : input float\n"
"  b : input float\n"
"  r : input float\n"
"  ad : input float\n"
"  bd : input float\n"
"  rd : input float\n"
"Return objects:\n"
"  v : rank-1 array('f') with bounds (6)";
/* extern void F_FUNC_US(sla_cs2c6,SLA_CS2C6)(float*,float*,float*,float*,float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_cs2c6(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float a = 0;
  PyObject *a_capi = Py_None;
  float b = 0;
  PyObject *b_capi = Py_None;
  float r = 0;
  PyObject *r_capi = Py_None;
  float ad = 0;
  PyObject *ad_capi = Py_None;
  float bd = 0;
  PyObject *bd_capi = Py_None;
  float rd = 0;
  PyObject *rd_capi = Py_None;
  float *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  static char *capi_kwlist[] = {"a","b","r","ad","bd","rd",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOO|:slalib.sla_cs2c6",\
    capi_kwlist,&a_capi,&b_capi,&r_capi,&ad_capi,&bd_capi,&rd_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
    f2py_success = float_from_pyobj(&a,a_capi,"slalib.sla_cs2c6() 1st argument (a) can't be converted to float");
  if (f2py_success) {
  /* Processing variable bd */
    f2py_success = float_from_pyobj(&bd,bd_capi,"slalib.sla_cs2c6() 5th argument (bd) can't be converted to float");
  if (f2py_success) {
  /* Processing variable r */
    f2py_success = float_from_pyobj(&r,r_capi,"slalib.sla_cs2c6() 3rd argument (r) can't be converted to float");
  if (f2py_success) {
  /* Processing variable b */
    f2py_success = float_from_pyobj(&b,b_capi,"slalib.sla_cs2c6() 2nd argument (b) can't be converted to float");
  if (f2py_success) {
  /* Processing variable ad */
    f2py_success = float_from_pyobj(&ad,ad_capi,"slalib.sla_cs2c6() 4th argument (ad) can't be converted to float");
  if (f2py_success) {
  /* Processing variable v */
  v_Dims[0]=6;
  capi_v_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_v_tmp = array_from_pyobj(PyArray_FLOAT,v_Dims,v_Rank,capi_v_intent,Py_None);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `v' of slalib.sla_cs2c6 to C/Fortran array" );
  } else {
    v = (float *)(capi_v_tmp->data);

  /* Processing variable rd */
    f2py_success = float_from_pyobj(&rd,rd_capi,"slalib.sla_cs2c6() 6th argument (rd) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&a,&b,&r,&ad,&bd,&rd,v);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_v_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of rd*/
  /* End of cleaning variable rd */
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  } /*if (f2py_success) of ad*/
  /* End of cleaning variable ad */
  } /*if (f2py_success) of b*/
  /* End of cleaning variable b */
  } /*if (f2py_success) of r*/
  /* End of cleaning variable r */
  } /*if (f2py_success) of bd*/
  /* End of cleaning variable bd */
  } /*if (f2py_success) of a*/
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_cs2c6 ******************************/

/********************************** sla_cs2c **********************************/
static char doc_f2py_rout_slalib_sla_cs2c[] = "\
Function signature:\n\
  v = sla_cs2c(a,b)\n\
Required arguments:\n"
"  a : input float\n"
"  b : input float\n"
"Return objects:\n"
"  v : rank-1 array('f') with bounds (3)";
/* extern void F_FUNC_US(sla_cs2c,SLA_CS2C)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_cs2c(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float a = 0;
  PyObject *a_capi = Py_None;
  float b = 0;
  PyObject *b_capi = Py_None;
  float *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  static char *capi_kwlist[] = {"a","b",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_cs2c",\
    capi_kwlist,&a_capi,&b_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
    f2py_success = float_from_pyobj(&a,a_capi,"slalib.sla_cs2c() 1st argument (a) can't be converted to float");
  if (f2py_success) {
  /* Processing variable b */
    f2py_success = float_from_pyobj(&b,b_capi,"slalib.sla_cs2c() 2nd argument (b) can't be converted to float");
  if (f2py_success) {
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_v_tmp = array_from_pyobj(PyArray_FLOAT,v_Dims,v_Rank,capi_v_intent,Py_None);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `v' of slalib.sla_cs2c to C/Fortran array" );
  } else {
    v = (float *)(capi_v_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&a,&b,v);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_v_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  } /*if (f2py_success) of b*/
  /* End of cleaning variable b */
  } /*if (f2py_success) of a*/
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_cs2c ******************************/

/********************************* sla_ctf2d *********************************/
static char doc_f2py_rout_slalib_sla_ctf2d[] = "\
Function signature:\n\
  days,j = sla_ctf2d(ihour,imin,sec)\n\
Required arguments:\n"
"  ihour : input int\n"
"  imin : input int\n"
"  sec : input float\n"
"Return objects:\n"
"  days : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_ctf2d,SLA_CTF2D)(int*,int*,float*,float*,int*); */
static PyObject *f2py_rout_slalib_sla_ctf2d(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,float*,float*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ihour = 0;
  PyObject *ihour_capi = Py_None;
  int imin = 0;
  PyObject *imin_capi = Py_None;
  float sec = 0;
  PyObject *sec_capi = Py_None;
  float days = 0;
  int j = 0;
  static char *capi_kwlist[] = {"ihour","imin","sec",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_ctf2d",\
    capi_kwlist,&ihour_capi,&imin_capi,&sec_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ihour */
    f2py_success = int_from_pyobj(&ihour,ihour_capi,"slalib.sla_ctf2d() 1st argument (ihour) can't be converted to int");
  if (f2py_success) {
  /* Processing variable imin */
    f2py_success = int_from_pyobj(&imin,imin_capi,"slalib.sla_ctf2d() 2nd argument (imin) can't be converted to int");
  if (f2py_success) {
  /* Processing variable sec */
    f2py_success = float_from_pyobj(&sec,sec_capi,"slalib.sla_ctf2d() 3rd argument (sec) can't be converted to float");
  if (f2py_success) {
  /* Processing variable days */
  /* Processing variable j */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ihour,&imin,&sec,&days,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("fi",days,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable j */
  /* End of cleaning variable days */
  } /*if (f2py_success) of sec*/
  /* End of cleaning variable sec */
  } /*if (f2py_success) of imin*/
  /* End of cleaning variable imin */
  } /*if (f2py_success) of ihour*/
  /* End of cleaning variable ihour */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_ctf2d ******************************/

/********************************* sla_ctf2r *********************************/
static char doc_f2py_rout_slalib_sla_ctf2r[] = "\
Function signature:\n\
  rad,j = sla_ctf2r(ihour,imin,sec)\n\
Required arguments:\n"
"  ihour : input int\n"
"  imin : input int\n"
"  sec : input float\n"
"Return objects:\n"
"  rad : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_ctf2r,SLA_CTF2R)(int*,int*,float*,float*,int*); */
static PyObject *f2py_rout_slalib_sla_ctf2r(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,float*,float*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ihour = 0;
  PyObject *ihour_capi = Py_None;
  int imin = 0;
  PyObject *imin_capi = Py_None;
  float sec = 0;
  PyObject *sec_capi = Py_None;
  float rad = 0;
  int j = 0;
  static char *capi_kwlist[] = {"ihour","imin","sec",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_ctf2r",\
    capi_kwlist,&ihour_capi,&imin_capi,&sec_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ihour */
    f2py_success = int_from_pyobj(&ihour,ihour_capi,"slalib.sla_ctf2r() 1st argument (ihour) can't be converted to int");
  if (f2py_success) {
  /* Processing variable imin */
    f2py_success = int_from_pyobj(&imin,imin_capi,"slalib.sla_ctf2r() 2nd argument (imin) can't be converted to int");
  if (f2py_success) {
  /* Processing variable sec */
    f2py_success = float_from_pyobj(&sec,sec_capi,"slalib.sla_ctf2r() 3rd argument (sec) can't be converted to float");
  if (f2py_success) {
  /* Processing variable rad */
  /* Processing variable j */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ihour,&imin,&sec,&rad,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("fi",rad,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable j */
  /* End of cleaning variable rad */
  } /*if (f2py_success) of sec*/
  /* End of cleaning variable sec */
  } /*if (f2py_success) of imin*/
  /* End of cleaning variable imin */
  } /*if (f2py_success) of ihour*/
  /* End of cleaning variable ihour */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_ctf2r ******************************/

/********************************* sla_daf2r *********************************/
static char doc_f2py_rout_slalib_sla_daf2r[] = "\
Function signature:\n\
  rad,j = sla_daf2r(ideg,iamin,asec)\n\
Required arguments:\n"
"  ideg : input int\n"
"  iamin : input int\n"
"  asec : input float\n"
"Return objects:\n"
"  rad : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_daf2r,SLA_DAF2R)(int*,int*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_daf2r(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ideg = 0;
  PyObject *ideg_capi = Py_None;
  int iamin = 0;
  PyObject *iamin_capi = Py_None;
  double asec = 0;
  PyObject *asec_capi = Py_None;
  double rad = 0;
  int j = 0;
  static char *capi_kwlist[] = {"ideg","iamin","asec",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_daf2r",\
    capi_kwlist,&ideg_capi,&iamin_capi,&asec_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable asec */
    f2py_success = double_from_pyobj(&asec,asec_capi,"slalib.sla_daf2r() 3rd argument (asec) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rad */
  /* Processing variable ideg */
    f2py_success = int_from_pyobj(&ideg,ideg_capi,"slalib.sla_daf2r() 1st argument (ideg) can't be converted to int");
  if (f2py_success) {
  /* Processing variable iamin */
    f2py_success = int_from_pyobj(&iamin,iamin_capi,"slalib.sla_daf2r() 2nd argument (iamin) can't be converted to int");
  if (f2py_success) {
  /* Processing variable j */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ideg,&iamin,&asec,&rad,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("di",rad,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable j */
  } /*if (f2py_success) of iamin*/
  /* End of cleaning variable iamin */
  } /*if (f2py_success) of ideg*/
  /* End of cleaning variable ideg */
  /* End of cleaning variable rad */
  } /*if (f2py_success) of asec*/
  /* End of cleaning variable asec */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_daf2r ******************************/

/********************************* sla_dafin *********************************/
static char doc_f2py_rout_slalib_sla_dafin[] = "\
Function signature:\n\
  iptr,a,j = sla_dafin(string_bn,iptr)\n\
Required arguments:\n"
"  string_bn : input string(len=-1)\n"
"  iptr : input int\n"
"Return objects:\n"
"  iptr : int\n"
"  a : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_dafin,SLA_DAFIN)(string,int*,double*,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_dafin(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,int*,double*,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string string_bn = NULL;
  int slen(string_bn);
  PyObject *string_bn_capi = Py_None;
  int iptr = 0;
  PyObject *iptr_capi = Py_None;
  double a = 0;
  int j = 0;
  static char *capi_kwlist[] = {"string_bn","iptr",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dafin",\
    capi_kwlist,&string_bn_capi,&iptr_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
  /* Processing variable iptr */
    f2py_success = int_from_pyobj(&iptr,iptr_capi,"slalib.sla_dafin() 2nd argument (iptr) can't be converted to int");
  if (f2py_success) {
  /* Processing variable j */
  /* Processing variable string_bn */
  slen(string_bn) = -1;
  f2py_success = string_from_pyobj(&string_bn,&slen(string_bn),"",string_bn_capi,"string_from_pyobj failed in converting 1st argument `string_bn' of slalib.sla_dafin to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(string_bn,&iptr,&a,&j,slen(string_bn));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("idi",iptr,a,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(string_bn);
  }  /*if (f2py_success) of string_bn*/
  /* End of cleaning variable string_bn */
  /* End of cleaning variable j */
  } /*if (f2py_success) of iptr*/
  /* End of cleaning variable iptr */
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dafin ******************************/

/********************************** sla_dat **********************************/
static char doc_f2py_rout_slalib_sla_dat[] = "\
Function signature:\n\
  sla_dat = sla_dat(utc)\n\
Required arguments:\n"
"  utc : input float\n"
"Return objects:\n"
"  sla_dat : float";
/* extern void F_WRAPPEDFUNC_US(sla_dat,SLA_DAT)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_dat(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_dat = 0;
  double utc = 0;
  PyObject *utc_capi = Py_None;
  static char *capi_kwlist[] = {"utc",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_dat",\
    capi_kwlist,&utc_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable utc */
    f2py_success = double_from_pyobj(&utc,utc_capi,"slalib.sla_dat() 1st argument (utc) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_dat */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_dat,&utc);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_dat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_dat */
  } /*if (f2py_success) of utc*/
  /* End of cleaning variable utc */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_dat *******************************/

/********************************* sla_dav2m *********************************/
static char doc_f2py_rout_slalib_sla_dav2m[] = "\
Function signature:\n\
  rmat = sla_dav2m(axvec)\n\
Required arguments:\n"
"  axvec : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  rmat : rank-2 array('d') with bounds (3,3)";
/* extern void F_FUNC_US(sla_dav2m,SLA_DAV2M)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_dav2m(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *axvec = NULL;
  npy_intp axvec_Dims[1] = {-1};
  const int axvec_Rank = 1;
  PyArrayObject *capi_axvec_tmp = NULL;
  int capi_axvec_intent = 0;
  PyObject *axvec_capi = Py_None;
  double *rmat = NULL;
  npy_intp rmat_Dims[2] = {-1, -1};
  const int rmat_Rank = 2;
  PyArrayObject *capi_rmat_tmp = NULL;
  int capi_rmat_intent = 0;
  static char *capi_kwlist[] = {"axvec",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_dav2m",\
    capi_kwlist,&axvec_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rmat */
  rmat_Dims[0]=3,rmat_Dims[1]=3;
  capi_rmat_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_rmat_tmp = array_from_pyobj(PyArray_DOUBLE,rmat_Dims,rmat_Rank,capi_rmat_intent,Py_None);
  if (capi_rmat_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `rmat' of slalib.sla_dav2m to C/Fortran array" );
  } else {
    rmat = (double *)(capi_rmat_tmp->data);

  /* Processing variable axvec */
  axvec_Dims[0]=3;
  capi_axvec_intent |= F2PY_INTENT_IN;
  capi_axvec_tmp = array_from_pyobj(PyArray_DOUBLE,axvec_Dims,axvec_Rank,capi_axvec_intent,axvec_capi);
  if (capi_axvec_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `axvec' of slalib.sla_dav2m to C/Fortran array" );
  } else {
    axvec = (double *)(capi_axvec_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(axvec,rmat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_rmat_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_axvec_tmp!=axvec_capi) {
    Py_XDECREF(capi_axvec_tmp); }
  }  /*if (capi_axvec_tmp == NULL) ... else of axvec*/
  /* End of cleaning variable axvec */
  }  /*if (capi_rmat_tmp == NULL) ... else of rmat*/
  /* End of cleaning variable rmat */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dav2m ******************************/

/********************************* sla_dbear *********************************/
static char doc_f2py_rout_slalib_sla_dbear[] = "\
Function signature:\n\
  sla_dbear = sla_dbear(a1,b1,a2,b2)\n\
Required arguments:\n"
"  a1 : input float\n"
"  b1 : input float\n"
"  a2 : input float\n"
"  b2 : input float\n"
"Return objects:\n"
"  sla_dbear : float";
/* extern void F_WRAPPEDFUNC_US(sla_dbear,SLA_DBEAR)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dbear(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_dbear = 0;
  double a1 = 0;
  PyObject *a1_capi = Py_None;
  double b1 = 0;
  PyObject *b1_capi = Py_None;
  double a2 = 0;
  PyObject *a2_capi = Py_None;
  double b2 = 0;
  PyObject *b2_capi = Py_None;
  static char *capi_kwlist[] = {"a1","b1","a2","b2",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_dbear",\
    capi_kwlist,&a1_capi,&b1_capi,&a2_capi,&b2_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a1 */
    f2py_success = double_from_pyobj(&a1,a1_capi,"slalib.sla_dbear() 1st argument (a1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable a2 */
    f2py_success = double_from_pyobj(&a2,a2_capi,"slalib.sla_dbear() 3rd argument (a2) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_dbear */
  /* Processing variable b1 */
    f2py_success = double_from_pyobj(&b1,b1_capi,"slalib.sla_dbear() 2nd argument (b1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable b2 */
    f2py_success = double_from_pyobj(&b2,b2_capi,"slalib.sla_dbear() 4th argument (b2) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_dbear,&a1,&b1,&a2,&b2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_dbear);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of b2*/
  /* End of cleaning variable b2 */
  } /*if (f2py_success) of b1*/
  /* End of cleaning variable b1 */
  /* End of cleaning variable sla_dbear */
  } /*if (f2py_success) of a2*/
  /* End of cleaning variable a2 */
  } /*if (f2py_success) of a1*/
  /* End of cleaning variable a1 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dbear ******************************/

/********************************* sla_dbjin *********************************/
static char doc_f2py_rout_slalib_sla_dbjin[] = "\
Function signature:\n\
  nstrt,dreslt,j1,j2 = sla_dbjin(string_bn,nstrt)\n\
Required arguments:\n"
"  string_bn : input string(len=-1)\n"
"  nstrt : input int\n"
"Return objects:\n"
"  nstrt : int\n"
"  dreslt : float\n"
"  j1 : int\n"
"  j2 : int";
/* extern void F_FUNC_US(sla_dbjin,SLA_DBJIN)(string,int*,double*,int*,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_dbjin(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,int*,double*,int*,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string string_bn = NULL;
  int slen(string_bn);
  PyObject *string_bn_capi = Py_None;
  int nstrt = 0;
  PyObject *nstrt_capi = Py_None;
  double dreslt = 0;
  int j1 = 0;
  int j2 = 0;
  static char *capi_kwlist[] = {"string_bn","nstrt",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dbjin",\
    capi_kwlist,&string_bn_capi,&nstrt_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dreslt */
  /* Processing variable nstrt */
    f2py_success = int_from_pyobj(&nstrt,nstrt_capi,"slalib.sla_dbjin() 2nd argument (nstrt) can't be converted to int");
  if (f2py_success) {
  /* Processing variable j1 */
  /* Processing variable j2 */
  /* Processing variable string_bn */
  slen(string_bn) = -1;
  f2py_success = string_from_pyobj(&string_bn,&slen(string_bn),"",string_bn_capi,"string_from_pyobj failed in converting 1st argument `string_bn' of slalib.sla_dbjin to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(string_bn,&nstrt,&dreslt,&j1,&j2,slen(string_bn));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("idii",nstrt,dreslt,j1,j2);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(string_bn);
  }  /*if (f2py_success) of string_bn*/
  /* End of cleaning variable string_bn */
  /* End of cleaning variable j2 */
  /* End of cleaning variable j1 */
  } /*if (f2py_success) of nstrt*/
  /* End of cleaning variable nstrt */
  /* End of cleaning variable dreslt */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dbjin ******************************/

/********************************* sla_dc62s *********************************/
static char doc_f2py_rout_slalib_sla_dc62s[] = "\
Function signature:\n\
  a,b,r,ad,bd,rd = sla_dc62s(v)\n\
Required arguments:\n"
"  v : input rank-1 array('d') with bounds (6)\n"
"Return objects:\n"
"  a : float\n"
"  b : float\n"
"  r : float\n"
"  ad : float\n"
"  bd : float\n"
"  rd : float";
/* extern void F_FUNC_US(sla_dc62s,SLA_DC62S)(double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dc62s(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  double a = 0;
  double b = 0;
  double r = 0;
  double ad = 0;
  double bd = 0;
  double rd = 0;
  static char *capi_kwlist[] = {"v",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_dc62s",\
    capi_kwlist,&v_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
  /* Processing variable bd */
  /* Processing variable r */
  /* Processing variable b */
  /* Processing variable ad */
  /* Processing variable v */
  v_Dims[0]=6;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_DOUBLE,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v' of slalib.sla_dc62s to C/Fortran array" );
  } else {
    v = (double *)(capi_v_tmp->data);

  /* Processing variable rd */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(v,&a,&b,&r,&ad,&bd,&rd);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dddddd",a,b,r,ad,bd,rd);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable rd */
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  /* End of cleaning variable ad */
  /* End of cleaning variable b */
  /* End of cleaning variable r */
  /* End of cleaning variable bd */
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dc62s ******************************/

/********************************* sla_dcc2s *********************************/
static char doc_f2py_rout_slalib_sla_dcc2s[] = "\
Function signature:\n\
  a,b = sla_dcc2s(v)\n\
Required arguments:\n"
"  v : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  a : float\n"
"  b : float";
/* extern void F_FUNC_US(sla_dcc2s,SLA_DCC2S)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dcc2s(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  double a = 0;
  double b = 0;
  static char *capi_kwlist[] = {"v",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_dcc2s",\
    capi_kwlist,&v_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
  /* Processing variable b */
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_DOUBLE,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v' of slalib.sla_dcc2s to C/Fortran array" );
  } else {
    v = (double *)(capi_v_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(v,&a,&b);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",a,b);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  /* End of cleaning variable b */
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dcc2s ******************************/

/********************************* sla_dcmpf *********************************/
static char doc_f2py_rout_slalib_sla_dcmpf[] = "\
Function signature:\n\
  xz,yz,xs,ys,perp,orient = sla_dcmpf(coeffs)\n\
Required arguments:\n"
"  coeffs : input rank-1 array('d') with bounds (6)\n"
"Return objects:\n"
"  xz : float\n"
"  yz : float\n"
"  xs : float\n"
"  ys : float\n"
"  perp : float\n"
"  orient : float";
/* extern void F_FUNC_US(sla_dcmpf,SLA_DCMPF)(double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dcmpf(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *coeffs = NULL;
  npy_intp coeffs_Dims[1] = {-1};
  const int coeffs_Rank = 1;
  PyArrayObject *capi_coeffs_tmp = NULL;
  int capi_coeffs_intent = 0;
  PyObject *coeffs_capi = Py_None;
  double xz = 0;
  double yz = 0;
  double xs = 0;
  double ys = 0;
  double perp = 0;
  double orient = 0;
  static char *capi_kwlist[] = {"coeffs",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_dcmpf",\
    capi_kwlist,&coeffs_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable xz */
  /* Processing variable yz */
  /* Processing variable perp */
  /* Processing variable coeffs */
  coeffs_Dims[0]=6;
  capi_coeffs_intent |= F2PY_INTENT_IN;
  capi_coeffs_tmp = array_from_pyobj(PyArray_DOUBLE,coeffs_Dims,coeffs_Rank,capi_coeffs_intent,coeffs_capi);
  if (capi_coeffs_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `coeffs' of slalib.sla_dcmpf to C/Fortran array" );
  } else {
    coeffs = (double *)(capi_coeffs_tmp->data);

  /* Processing variable xs */
  /* Processing variable ys */
  /* Processing variable orient */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(coeffs,&xz,&yz,&xs,&ys,&perp,&orient);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dddddd",xz,yz,xs,ys,perp,orient);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable orient */
  /* End of cleaning variable ys */
  /* End of cleaning variable xs */
  if((PyObject *)capi_coeffs_tmp!=coeffs_capi) {
    Py_XDECREF(capi_coeffs_tmp); }
  }  /*if (capi_coeffs_tmp == NULL) ... else of coeffs*/
  /* End of cleaning variable coeffs */
  /* End of cleaning variable perp */
  /* End of cleaning variable yz */
  /* End of cleaning variable xz */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dcmpf ******************************/

/********************************* sla_dcs2c *********************************/
static char doc_f2py_rout_slalib_sla_dcs2c[] = "\
Function signature:\n\
  v = sla_dcs2c(a,b)\n\
Required arguments:\n"
"  a : input float\n"
"  b : input float\n"
"Return objects:\n"
"  v : rank-1 array('d') with bounds (3)";
/* extern void F_FUNC_US(sla_dcs2c,SLA_DCS2C)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dcs2c(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double a = 0;
  PyObject *a_capi = Py_None;
  double b = 0;
  PyObject *b_capi = Py_None;
  double *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  static char *capi_kwlist[] = {"a","b",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dcs2c",\
    capi_kwlist,&a_capi,&b_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
    f2py_success = double_from_pyobj(&a,a_capi,"slalib.sla_dcs2c() 1st argument (a) can't be converted to double");
  if (f2py_success) {
  /* Processing variable b */
    f2py_success = double_from_pyobj(&b,b_capi,"slalib.sla_dcs2c() 2nd argument (b) can't be converted to double");
  if (f2py_success) {
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_v_tmp = array_from_pyobj(PyArray_DOUBLE,v_Dims,v_Rank,capi_v_intent,Py_None);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `v' of slalib.sla_dcs2c to C/Fortran array" );
  } else {
    v = (double *)(capi_v_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&a,&b,v);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_v_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  } /*if (f2py_success) of b*/
  /* End of cleaning variable b */
  } /*if (f2py_success) of a*/
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dcs2c ******************************/

/********************************* sla_dd2tf *********************************/
static char doc_f2py_rout_slalib_sla_dd2tf[] = "\
Function signature:\n\
  sign,ihmsf = sla_dd2tf(ndp,days)\n\
Required arguments:\n"
"  ndp : input int\n"
"  days : input float\n"
"Return objects:\n"
"  sign : string(len=1)\n"
"  ihmsf : rank-1 array('i') with bounds (4)";
/* extern void F_FUNC_US(sla_dd2tf,SLA_DD2TF)(int*,double*,string,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_dd2tf(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,double*,string,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ndp = 0;
  PyObject *ndp_capi = Py_None;
  double days = 0;
  PyObject *days_capi = Py_None;
  string sign = NULL;
  int slen(sign);
  PyObject *sign_capi = Py_None;
  int *ihmsf = NULL;
  npy_intp ihmsf_Dims[1] = {-1};
  const int ihmsf_Rank = 1;
  PyArrayObject *capi_ihmsf_tmp = NULL;
  int capi_ihmsf_intent = 0;
  static char *capi_kwlist[] = {"ndp","days",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dd2tf",\
    capi_kwlist,&ndp_capi,&days_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ndp */
    f2py_success = int_from_pyobj(&ndp,ndp_capi,"slalib.sla_dd2tf() 1st argument (ndp) can't be converted to int");
  if (f2py_success) {
  /* Processing variable days */
    f2py_success = double_from_pyobj(&days,days_capi,"slalib.sla_dd2tf() 2nd argument (days) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ihmsf */
  ihmsf_Dims[0]=4;
  capi_ihmsf_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_ihmsf_tmp = array_from_pyobj(PyArray_INT,ihmsf_Dims,ihmsf_Rank,capi_ihmsf_intent,Py_None);
  if (capi_ihmsf_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `ihmsf' of slalib.sla_dd2tf to C/Fortran array" );
  } else {
    ihmsf = (int *)(capi_ihmsf_tmp->data);

  /* Processing variable sign */
  slen(sign) = 1;
  f2py_success = string_from_pyobj(&sign,&slen(sign),"",sign_capi,"string_from_pyobj failed in converting hidden `sign' of slalib.sla_dd2tf to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ndp,&days,sign,ihmsf,slen(sign));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("zN",sign,capi_ihmsf_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(sign);
  }  /*if (f2py_success) of sign*/
  /* End of cleaning variable sign */
  }  /*if (capi_ihmsf_tmp == NULL) ... else of ihmsf*/
  /* End of cleaning variable ihmsf */
  } /*if (f2py_success) of days*/
  /* End of cleaning variable days */
  } /*if (f2py_success) of ndp*/
  /* End of cleaning variable ndp */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dd2tf ******************************/

/********************************** sla_de2h **********************************/
static char doc_f2py_rout_slalib_sla_de2h[] = "\
Function signature:\n\
  az,el = sla_de2h(ha,dec,phi)\n\
Required arguments:\n"
"  ha : input float\n"
"  dec : input float\n"
"  phi : input float\n"
"Return objects:\n"
"  az : float\n"
"  el : float";
/* extern void F_FUNC_US(sla_de2h,SLA_DE2H)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_de2h(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double ha = 0;
  PyObject *ha_capi = Py_None;
  double dec = 0;
  PyObject *dec_capi = Py_None;
  double phi = 0;
  PyObject *phi_capi = Py_None;
  double az = 0;
  double el = 0;
  static char *capi_kwlist[] = {"ha","dec","phi",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_de2h",\
    capi_kwlist,&ha_capi,&dec_capi,&phi_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ha */
    f2py_success = double_from_pyobj(&ha,ha_capi,"slalib.sla_de2h() 1st argument (ha) can't be converted to double");
  if (f2py_success) {
  /* Processing variable el */
  /* Processing variable phi */
    f2py_success = double_from_pyobj(&phi,phi_capi,"slalib.sla_de2h() 3rd argument (phi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable az */
  /* Processing variable dec */
    f2py_success = double_from_pyobj(&dec,dec_capi,"slalib.sla_de2h() 2nd argument (dec) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ha,&dec,&phi,&az,&el);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",az,el);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of dec*/
  /* End of cleaning variable dec */
  /* End of cleaning variable az */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
  /* End of cleaning variable el */
  } /*if (f2py_success) of ha*/
  /* End of cleaning variable ha */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_de2h ******************************/

/********************************* sla_deuler *********************************/
static char doc_f2py_rout_slalib_sla_deuler[] = "\
Function signature:\n\
  rmat = sla_deuler(order,phi,theta,psi)\n\
Required arguments:\n"
"  order : input string(len=-1)\n"
"  phi : input float\n"
"  theta : input float\n"
"  psi : input float\n"
"Return objects:\n"
"  rmat : rank-2 array('d') with bounds (3,3)";
/* extern void F_FUNC_US(sla_deuler,SLA_DEULER)(string,double*,double*,double*,double*,size_t); */
static PyObject *f2py_rout_slalib_sla_deuler(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,double*,double*,double*,double*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string order = NULL;
  int slen(order);
  PyObject *order_capi = Py_None;
  double phi = 0;
  PyObject *phi_capi = Py_None;
  double theta = 0;
  PyObject *theta_capi = Py_None;
  double psi = 0;
  PyObject *psi_capi = Py_None;
  double *rmat = NULL;
  npy_intp rmat_Dims[2] = {-1, -1};
  const int rmat_Rank = 2;
  PyArrayObject *capi_rmat_tmp = NULL;
  int capi_rmat_intent = 0;
  static char *capi_kwlist[] = {"order","phi","theta","psi",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_deuler",\
    capi_kwlist,&order_capi,&phi_capi,&theta_capi,&psi_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rmat */
  rmat_Dims[0]=3,rmat_Dims[1]=3;
  capi_rmat_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_rmat_tmp = array_from_pyobj(PyArray_DOUBLE,rmat_Dims,rmat_Rank,capi_rmat_intent,Py_None);
  if (capi_rmat_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `rmat' of slalib.sla_deuler to C/Fortran array" );
  } else {
    rmat = (double *)(capi_rmat_tmp->data);

  /* Processing variable theta */
    f2py_success = double_from_pyobj(&theta,theta_capi,"slalib.sla_deuler() 3rd argument (theta) can't be converted to double");
  if (f2py_success) {
  /* Processing variable phi */
    f2py_success = double_from_pyobj(&phi,phi_capi,"slalib.sla_deuler() 2nd argument (phi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable psi */
    f2py_success = double_from_pyobj(&psi,psi_capi,"slalib.sla_deuler() 4th argument (psi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable order */
  slen(order) = -1;
  f2py_success = string_from_pyobj(&order,&slen(order),"",order_capi,"string_from_pyobj failed in converting 1st argument `order' of slalib.sla_deuler to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(order,&phi,&theta,&psi,rmat,slen(order));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_rmat_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(order);
  }  /*if (f2py_success) of order*/
  /* End of cleaning variable order */
  } /*if (f2py_success) of psi*/
  /* End of cleaning variable psi */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
  } /*if (f2py_success) of theta*/
  /* End of cleaning variable theta */
  }  /*if (capi_rmat_tmp == NULL) ... else of rmat*/
  /* End of cleaning variable rmat */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_deuler *****************************/

/********************************* sla_dfltin *********************************/
static char doc_f2py_rout_slalib_sla_dfltin[] = "\
Function signature:\n\
  nstrt,dreslt,jflag = sla_dfltin(string_bn,nstrt)\n\
Required arguments:\n"
"  string_bn : input string(len=-1)\n"
"  nstrt : input int\n"
"Return objects:\n"
"  nstrt : int\n"
"  dreslt : float\n"
"  jflag : int";
/* extern void F_FUNC_US(sla_dfltin,SLA_DFLTIN)(string,int*,double*,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_dfltin(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,int*,double*,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string string_bn = NULL;
  int slen(string_bn);
  PyObject *string_bn_capi = Py_None;
  int nstrt = 0;
  PyObject *nstrt_capi = Py_None;
  double dreslt = 0;
  int jflag = 0;
  static char *capi_kwlist[] = {"string_bn","nstrt",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dfltin",\
    capi_kwlist,&string_bn_capi,&nstrt_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dreslt */
  /* Processing variable nstrt */
    f2py_success = int_from_pyobj(&nstrt,nstrt_capi,"slalib.sla_dfltin() 2nd argument (nstrt) can't be converted to int");
  if (f2py_success) {
  /* Processing variable jflag */
  /* Processing variable string_bn */
  slen(string_bn) = -1;
  f2py_success = string_from_pyobj(&string_bn,&slen(string_bn),"",string_bn_capi,"string_from_pyobj failed in converting 1st argument `string_bn' of slalib.sla_dfltin to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(string_bn,&nstrt,&dreslt,&jflag,slen(string_bn));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("idi",nstrt,dreslt,jflag);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(string_bn);
  }  /*if (f2py_success) of string_bn*/
  /* End of cleaning variable string_bn */
  /* End of cleaning variable jflag */
  } /*if (f2py_success) of nstrt*/
  /* End of cleaning variable nstrt */
  /* End of cleaning variable dreslt */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_dfltin *****************************/

/********************************** sla_dh2e **********************************/
static char doc_f2py_rout_slalib_sla_dh2e[] = "\
Function signature:\n\
  ha,dec = sla_dh2e(az,el,phi)\n\
Required arguments:\n"
"  az : input float\n"
"  el : input float\n"
"  phi : input float\n"
"Return objects:\n"
"  ha : float\n"
"  dec : float";
/* extern void F_FUNC_US(sla_dh2e,SLA_DH2E)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dh2e(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double az = 0;
  PyObject *az_capi = Py_None;
  double el = 0;
  PyObject *el_capi = Py_None;
  double phi = 0;
  PyObject *phi_capi = Py_None;
  double ha = 0;
  double dec = 0;
  static char *capi_kwlist[] = {"az","el","phi",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_dh2e",\
    capi_kwlist,&az_capi,&el_capi,&phi_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dec */
  /* Processing variable el */
    f2py_success = double_from_pyobj(&el,el_capi,"slalib.sla_dh2e() 2nd argument (el) can't be converted to double");
  if (f2py_success) {
  /* Processing variable phi */
    f2py_success = double_from_pyobj(&phi,phi_capi,"slalib.sla_dh2e() 3rd argument (phi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ha */
  /* Processing variable az */
    f2py_success = double_from_pyobj(&az,az_capi,"slalib.sla_dh2e() 1st argument (az) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&az,&el,&phi,&ha,&dec);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",ha,dec);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of az*/
  /* End of cleaning variable az */
  /* End of cleaning variable ha */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
  } /*if (f2py_success) of el*/
  /* End of cleaning variable el */
  /* End of cleaning variable dec */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dh2e ******************************/

/********************************* sla_dimxv *********************************/
static char doc_f2py_rout_slalib_sla_dimxv[] = "\
Function signature:\n\
  vb = sla_dimxv(dm,va)\n\
Required arguments:\n"
"  dm : input rank-2 array('d') with bounds (3,3)\n"
"  va : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  vb : rank-1 array('d') with bounds (3)";
/* extern void F_FUNC_US(sla_dimxv,SLA_DIMXV)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dimxv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *dm = NULL;
  npy_intp dm_Dims[2] = {-1, -1};
  const int dm_Rank = 2;
  PyArrayObject *capi_dm_tmp = NULL;
  int capi_dm_intent = 0;
  PyObject *dm_capi = Py_None;
  double *va = NULL;
  npy_intp va_Dims[1] = {-1};
  const int va_Rank = 1;
  PyArrayObject *capi_va_tmp = NULL;
  int capi_va_intent = 0;
  PyObject *va_capi = Py_None;
  double *vb = NULL;
  npy_intp vb_Dims[1] = {-1};
  const int vb_Rank = 1;
  PyArrayObject *capi_vb_tmp = NULL;
  int capi_vb_intent = 0;
  static char *capi_kwlist[] = {"dm","va",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dimxv",\
    capi_kwlist,&dm_capi,&va_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable va */
  va_Dims[0]=3;
  capi_va_intent |= F2PY_INTENT_IN;
  capi_va_tmp = array_from_pyobj(PyArray_DOUBLE,va_Dims,va_Rank,capi_va_intent,va_capi);
  if (capi_va_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `va' of slalib.sla_dimxv to C/Fortran array" );
  } else {
    va = (double *)(capi_va_tmp->data);

  /* Processing variable vb */
  vb_Dims[0]=3;
  capi_vb_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_vb_tmp = array_from_pyobj(PyArray_DOUBLE,vb_Dims,vb_Rank,capi_vb_intent,Py_None);
  if (capi_vb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `vb' of slalib.sla_dimxv to C/Fortran array" );
  } else {
    vb = (double *)(capi_vb_tmp->data);

  /* Processing variable dm */
  dm_Dims[0]=3,dm_Dims[1]=3;
  capi_dm_intent |= F2PY_INTENT_IN;
  capi_dm_tmp = array_from_pyobj(PyArray_DOUBLE,dm_Dims,dm_Rank,capi_dm_intent,dm_capi);
  if (capi_dm_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `dm' of slalib.sla_dimxv to C/Fortran array" );
  } else {
    dm = (double *)(capi_dm_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(dm,va,vb);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_vb_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_dm_tmp!=dm_capi) {
    Py_XDECREF(capi_dm_tmp); }
  }  /*if (capi_dm_tmp == NULL) ... else of dm*/
  /* End of cleaning variable dm */
  }  /*if (capi_vb_tmp == NULL) ... else of vb*/
  /* End of cleaning variable vb */
  if((PyObject *)capi_va_tmp!=va_capi) {
    Py_XDECREF(capi_va_tmp); }
  }  /*if (capi_va_tmp == NULL) ... else of va*/
  /* End of cleaning variable va */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dimxv ******************************/

/********************************* sla_djcal *********************************/
static char doc_f2py_rout_slalib_sla_djcal[] = "\
Function signature:\n\
  iymdf,j = sla_djcal(ndp,djm)\n\
Required arguments:\n"
"  ndp : input int\n"
"  djm : input float\n"
"Return objects:\n"
"  iymdf : rank-1 array('i') with bounds (4)\n"
"  j : int";
/* extern void F_FUNC_US(sla_djcal,SLA_DJCAL)(int*,double*,int*,int*); */
static PyObject *f2py_rout_slalib_sla_djcal(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,double*,int*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ndp = 0;
  PyObject *ndp_capi = Py_None;
  double djm = 0;
  PyObject *djm_capi = Py_None;
  int *iymdf = NULL;
  npy_intp iymdf_Dims[1] = {-1};
  const int iymdf_Rank = 1;
  PyArrayObject *capi_iymdf_tmp = NULL;
  int capi_iymdf_intent = 0;
  int j = 0;
  static char *capi_kwlist[] = {"ndp","djm",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_djcal",\
    capi_kwlist,&ndp_capi,&djm_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ndp */
    f2py_success = int_from_pyobj(&ndp,ndp_capi,"slalib.sla_djcal() 1st argument (ndp) can't be converted to int");
  if (f2py_success) {
  /* Processing variable j */
  /* Processing variable djm */
    f2py_success = double_from_pyobj(&djm,djm_capi,"slalib.sla_djcal() 2nd argument (djm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable iymdf */
  iymdf_Dims[0]=4;
  capi_iymdf_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_iymdf_tmp = array_from_pyobj(PyArray_INT,iymdf_Dims,iymdf_Rank,capi_iymdf_intent,Py_None);
  if (capi_iymdf_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `iymdf' of slalib.sla_djcal to C/Fortran array" );
  } else {
    iymdf = (int *)(capi_iymdf_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ndp,&djm,iymdf,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Ni",capi_iymdf_tmp,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_iymdf_tmp == NULL) ... else of iymdf*/
  /* End of cleaning variable iymdf */
  } /*if (f2py_success) of djm*/
  /* End of cleaning variable djm */
  /* End of cleaning variable j */
  } /*if (f2py_success) of ndp*/
  /* End of cleaning variable ndp */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_djcal ******************************/

/********************************** sla_djcl **********************************/
static char doc_f2py_rout_slalib_sla_djcl[] = "\
Function signature:\n\
  iy,im,id,fd,j = sla_djcl(djm)\n\
Required arguments:\n"
"  djm : input float\n"
"Return objects:\n"
"  iy : int\n"
"  im : int\n"
"  id : int\n"
"  fd : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_djcl,SLA_DJCL)(double*,int*,int*,int*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_djcl(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,int*,int*,int*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double djm = 0;
  PyObject *djm_capi = Py_None;
  int iy = 0;
  int im = 0;
  int id = 0;
  double fd = 0;
  int j = 0;
  static char *capi_kwlist[] = {"djm",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_djcl",\
    capi_kwlist,&djm_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable iy */
  /* Processing variable im */
  /* Processing variable fd */
  /* Processing variable j */
  /* Processing variable djm */
    f2py_success = double_from_pyobj(&djm,djm_capi,"slalib.sla_djcl() 1st argument (djm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable id */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&djm,&iy,&im,&id,&fd,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("iiidi",iy,im,id,fd,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable id */
  } /*if (f2py_success) of djm*/
  /* End of cleaning variable djm */
  /* End of cleaning variable j */
  /* End of cleaning variable fd */
  /* End of cleaning variable im */
  /* End of cleaning variable iy */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_djcl ******************************/

/********************************* sla_dm2av *********************************/
static char doc_f2py_rout_slalib_sla_dm2av[] = "\
Function signature:\n\
  axvec = sla_dm2av(rmat)\n\
Required arguments:\n"
"  rmat : input rank-2 array('d') with bounds (3,3)\n"
"Return objects:\n"
"  axvec : rank-1 array('d') with bounds (3)";
/* extern void F_FUNC_US(sla_dm2av,SLA_DM2AV)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_dm2av(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *rmat = NULL;
  npy_intp rmat_Dims[2] = {-1, -1};
  const int rmat_Rank = 2;
  PyArrayObject *capi_rmat_tmp = NULL;
  int capi_rmat_intent = 0;
  PyObject *rmat_capi = Py_None;
  double *axvec = NULL;
  npy_intp axvec_Dims[1] = {-1};
  const int axvec_Rank = 1;
  PyArrayObject *capi_axvec_tmp = NULL;
  int capi_axvec_intent = 0;
  static char *capi_kwlist[] = {"rmat",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_dm2av",\
    capi_kwlist,&rmat_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rmat */
  rmat_Dims[0]=3,rmat_Dims[1]=3;
  capi_rmat_intent |= F2PY_INTENT_IN;
  capi_rmat_tmp = array_from_pyobj(PyArray_DOUBLE,rmat_Dims,rmat_Rank,capi_rmat_intent,rmat_capi);
  if (capi_rmat_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `rmat' of slalib.sla_dm2av to C/Fortran array" );
  } else {
    rmat = (double *)(capi_rmat_tmp->data);

  /* Processing variable axvec */
  axvec_Dims[0]=3;
  capi_axvec_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_axvec_tmp = array_from_pyobj(PyArray_DOUBLE,axvec_Dims,axvec_Rank,capi_axvec_intent,Py_None);
  if (capi_axvec_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `axvec' of slalib.sla_dm2av to C/Fortran array" );
  } else {
    axvec = (double *)(capi_axvec_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(rmat,axvec);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_axvec_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_axvec_tmp == NULL) ... else of axvec*/
  /* End of cleaning variable axvec */
  if((PyObject *)capi_rmat_tmp!=rmat_capi) {
    Py_XDECREF(capi_rmat_tmp); }
  }  /*if (capi_rmat_tmp == NULL) ... else of rmat*/
  /* End of cleaning variable rmat */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dm2av ******************************/

/********************************** sla_dmat **********************************/
static char doc_f2py_rout_slalib_sla_dmat[] = "\
Function signature:\n\
  a,y,d,jf,iw = sla_dmat(a,y,iw,[n])\n\
Required arguments:\n"
"  a : input rank-2 array('d') with bounds (n,n)\n"
"  y : input rank-1 array('d') with bounds (n)\n"
"  iw : input rank-1 array('i') with bounds (n)\n"
"Optional arguments:\n"
"  n := shape(a,0) input int\n"
"Return objects:\n"
"  a : rank-2 array('d') with bounds (n,n)\n"
"  y : rank-1 array('d') with bounds (n)\n"
"  d : float\n"
"  jf : int\n"
"  iw : rank-1 array('i') with bounds (n)";
/* extern void F_FUNC_US(sla_dmat,SLA_DMAT)(int*,double*,double*,double*,int*,int*); */
static PyObject *f2py_rout_slalib_sla_dmat(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,double*,double*,double*,int*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int n = 0;
  PyObject *n_capi = Py_None;
  double *a = NULL;
  npy_intp a_Dims[2] = {-1, -1};
  const int a_Rank = 2;
  PyArrayObject *capi_a_tmp = NULL;
  int capi_a_intent = 0;
  PyObject *a_capi = Py_None;
  double *y = NULL;
  npy_intp y_Dims[1] = {-1};
  const int y_Rank = 1;
  PyArrayObject *capi_y_tmp = NULL;
  int capi_y_intent = 0;
  PyObject *y_capi = Py_None;
  double d = 0;
  int jf = 0;
  int *iw = NULL;
  npy_intp iw_Dims[1] = {-1};
  const int iw_Rank = 1;
  PyArrayObject *capi_iw_tmp = NULL;
  int capi_iw_intent = 0;
  PyObject *iw_capi = Py_None;
  static char *capi_kwlist[] = {"a","y","iw","n",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|O:slalib.sla_dmat",\
    capi_kwlist,&a_capi,&y_capi,&iw_capi,&n_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
  ;
  capi_a_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_a_tmp = array_from_pyobj(PyArray_DOUBLE,a_Dims,a_Rank,capi_a_intent,a_capi);
  if (capi_a_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `a' of slalib.sla_dmat to C/Fortran array" );
  } else {
    a = (double *)(capi_a_tmp->data);

  /* Processing variable d */
  /* Processing variable jf */
  /* Processing variable n */
  if (n_capi == Py_None) n = shape(a,0); else
    f2py_success = int_from_pyobj(&n,n_capi,"slalib.sla_dmat() 1st keyword (n) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(shape(a,0)==n,"shape(a,0)==n","1st keyword n","sla_dmat:n=%d",n) {
  /* Processing variable y */
  y_Dims[0]=n;
  capi_y_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_y_tmp = array_from_pyobj(PyArray_DOUBLE,y_Dims,y_Rank,capi_y_intent,y_capi);
  if (capi_y_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `y' of slalib.sla_dmat to C/Fortran array" );
  } else {
    y = (double *)(capi_y_tmp->data);

  /* Processing variable iw */
  iw_Dims[0]=n;
  capi_iw_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_iw_tmp = array_from_pyobj(PyArray_INT,iw_Dims,iw_Rank,capi_iw_intent,iw_capi);
  if (capi_iw_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `iw' of slalib.sla_dmat to C/Fortran array" );
  } else {
    iw = (int *)(capi_iw_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&n,a,y,&d,&jf,iw);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("NNdiN",capi_a_tmp,capi_y_tmp,d,jf,capi_iw_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_iw_tmp == NULL) ... else of iw*/
  /* End of cleaning variable iw */
  }  /*if (capi_y_tmp == NULL) ... else of y*/
  /* End of cleaning variable y */
  } /*CHECKSCALAR(shape(a,0)==n)*/
  } /*if (f2py_success) of n*/
  /* End of cleaning variable n */
  /* End of cleaning variable jf */
  /* End of cleaning variable d */
  }  /*if (capi_a_tmp == NULL) ... else of a*/
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dmat ******************************/

/********************************* sla_dmoon *********************************/
static char doc_f2py_rout_slalib_sla_dmoon[] = "\
Function signature:\n\
  pv = sla_dmoon(date)\n\
Required arguments:\n"
"  date : input float\n"
"Return objects:\n"
"  pv : rank-1 array('d') with bounds (6)";
/* extern void F_FUNC_US(sla_dmoon,SLA_DMOON)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_dmoon(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double *pv = NULL;
  npy_intp pv_Dims[1] = {-1};
  const int pv_Rank = 1;
  PyArrayObject *capi_pv_tmp = NULL;
  int capi_pv_intent = 0;
  static char *capi_kwlist[] = {"date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_dmoon",\
    capi_kwlist,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_dmoon() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable pv */
  pv_Dims[0]=6;
  capi_pv_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_pv_tmp = array_from_pyobj(PyArray_DOUBLE,pv_Dims,pv_Rank,capi_pv_intent,Py_None);
  if (capi_pv_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `pv' of slalib.sla_dmoon to C/Fortran array" );
  } else {
    pv = (double *)(capi_pv_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,pv);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_pv_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_pv_tmp == NULL) ... else of pv*/
  /* End of cleaning variable pv */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dmoon ******************************/

/********************************** sla_dmxm **********************************/
static char doc_f2py_rout_slalib_sla_dmxm[] = "\
Function signature:\n\
  c = sla_dmxm(a,b)\n\
Required arguments:\n"
"  a : input rank-2 array('d') with bounds (3,3)\n"
"  b : input rank-2 array('d') with bounds (3,3)\n"
"Return objects:\n"
"  c : rank-2 array('d') with bounds (3,3)";
/* extern void F_FUNC_US(sla_dmxm,SLA_DMXM)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dmxm(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *a = NULL;
  npy_intp a_Dims[2] = {-1, -1};
  const int a_Rank = 2;
  PyArrayObject *capi_a_tmp = NULL;
  int capi_a_intent = 0;
  PyObject *a_capi = Py_None;
  double *b = NULL;
  npy_intp b_Dims[2] = {-1, -1};
  const int b_Rank = 2;
  PyArrayObject *capi_b_tmp = NULL;
  int capi_b_intent = 0;
  PyObject *b_capi = Py_None;
  double *c = NULL;
  npy_intp c_Dims[2] = {-1, -1};
  const int c_Rank = 2;
  PyArrayObject *capi_c_tmp = NULL;
  int capi_c_intent = 0;
  static char *capi_kwlist[] = {"a","b",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dmxm",\
    capi_kwlist,&a_capi,&b_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
  a_Dims[0]=3,a_Dims[1]=3;
  capi_a_intent |= F2PY_INTENT_IN;
  capi_a_tmp = array_from_pyobj(PyArray_DOUBLE,a_Dims,a_Rank,capi_a_intent,a_capi);
  if (capi_a_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `a' of slalib.sla_dmxm to C/Fortran array" );
  } else {
    a = (double *)(capi_a_tmp->data);

  /* Processing variable c */
  c_Dims[0]=3,c_Dims[1]=3;
  capi_c_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_c_tmp = array_from_pyobj(PyArray_DOUBLE,c_Dims,c_Rank,capi_c_intent,Py_None);
  if (capi_c_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `c' of slalib.sla_dmxm to C/Fortran array" );
  } else {
    c = (double *)(capi_c_tmp->data);

  /* Processing variable b */
  b_Dims[0]=3,b_Dims[1]=3;
  capi_b_intent |= F2PY_INTENT_IN;
  capi_b_tmp = array_from_pyobj(PyArray_DOUBLE,b_Dims,b_Rank,capi_b_intent,b_capi);
  if (capi_b_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `b' of slalib.sla_dmxm to C/Fortran array" );
  } else {
    b = (double *)(capi_b_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(a,b,c);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_c_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_b_tmp!=b_capi) {
    Py_XDECREF(capi_b_tmp); }
  }  /*if (capi_b_tmp == NULL) ... else of b*/
  /* End of cleaning variable b */
  }  /*if (capi_c_tmp == NULL) ... else of c*/
  /* End of cleaning variable c */
  if((PyObject *)capi_a_tmp!=a_capi) {
    Py_XDECREF(capi_a_tmp); }
  }  /*if (capi_a_tmp == NULL) ... else of a*/
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dmxm ******************************/

/********************************** sla_dmxv **********************************/
static char doc_f2py_rout_slalib_sla_dmxv[] = "\
Function signature:\n\
  vb = sla_dmxv(dm,va)\n\
Required arguments:\n"
"  dm : input rank-2 array('d') with bounds (3,3)\n"
"  va : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  vb : rank-1 array('d') with bounds (3)";
/* extern void F_FUNC_US(sla_dmxv,SLA_DMXV)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dmxv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *dm = NULL;
  npy_intp dm_Dims[2] = {-1, -1};
  const int dm_Rank = 2;
  PyArrayObject *capi_dm_tmp = NULL;
  int capi_dm_intent = 0;
  PyObject *dm_capi = Py_None;
  double *va = NULL;
  npy_intp va_Dims[1] = {-1};
  const int va_Rank = 1;
  PyArrayObject *capi_va_tmp = NULL;
  int capi_va_intent = 0;
  PyObject *va_capi = Py_None;
  double *vb = NULL;
  npy_intp vb_Dims[1] = {-1};
  const int vb_Rank = 1;
  PyArrayObject *capi_vb_tmp = NULL;
  int capi_vb_intent = 0;
  static char *capi_kwlist[] = {"dm","va",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dmxv",\
    capi_kwlist,&dm_capi,&va_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable va */
  va_Dims[0]=3;
  capi_va_intent |= F2PY_INTENT_IN;
  capi_va_tmp = array_from_pyobj(PyArray_DOUBLE,va_Dims,va_Rank,capi_va_intent,va_capi);
  if (capi_va_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `va' of slalib.sla_dmxv to C/Fortran array" );
  } else {
    va = (double *)(capi_va_tmp->data);

  /* Processing variable vb */
  vb_Dims[0]=3;
  capi_vb_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_vb_tmp = array_from_pyobj(PyArray_DOUBLE,vb_Dims,vb_Rank,capi_vb_intent,Py_None);
  if (capi_vb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `vb' of slalib.sla_dmxv to C/Fortran array" );
  } else {
    vb = (double *)(capi_vb_tmp->data);

  /* Processing variable dm */
  dm_Dims[0]=3,dm_Dims[1]=3;
  capi_dm_intent |= F2PY_INTENT_IN;
  capi_dm_tmp = array_from_pyobj(PyArray_DOUBLE,dm_Dims,dm_Rank,capi_dm_intent,dm_capi);
  if (capi_dm_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `dm' of slalib.sla_dmxv to C/Fortran array" );
  } else {
    dm = (double *)(capi_dm_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(dm,va,vb);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_vb_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_dm_tmp!=dm_capi) {
    Py_XDECREF(capi_dm_tmp); }
  }  /*if (capi_dm_tmp == NULL) ... else of dm*/
  /* End of cleaning variable dm */
  }  /*if (capi_vb_tmp == NULL) ... else of vb*/
  /* End of cleaning variable vb */
  if((PyObject *)capi_va_tmp!=va_capi) {
    Py_XDECREF(capi_va_tmp); }
  }  /*if (capi_va_tmp == NULL) ... else of va*/
  /* End of cleaning variable va */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dmxv ******************************/

/********************************** sla_dpav **********************************/
static char doc_f2py_rout_slalib_sla_dpav[] = "\
Function signature:\n\
  sla_dpav = sla_dpav(v1,v2)\n\
Required arguments:\n"
"  v1 : input rank-1 array('d') with bounds (3)\n"
"  v2 : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  sla_dpav : float";
/* extern void F_WRAPPEDFUNC_US(sla_dpav,SLA_DPAV)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dpav(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_dpav = 0;
  double *v1 = NULL;
  npy_intp v1_Dims[1] = {-1};
  const int v1_Rank = 1;
  PyArrayObject *capi_v1_tmp = NULL;
  int capi_v1_intent = 0;
  PyObject *v1_capi = Py_None;
  double *v2 = NULL;
  npy_intp v2_Dims[1] = {-1};
  const int v2_Rank = 1;
  PyArrayObject *capi_v2_tmp = NULL;
  int capi_v2_intent = 0;
  PyObject *v2_capi = Py_None;
  static char *capi_kwlist[] = {"v1","v2",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dpav",\
    capi_kwlist,&v1_capi,&v2_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable sla_dpav */
  /* Processing variable v1 */
  v1_Dims[0]=3;
  capi_v1_intent |= F2PY_INTENT_IN;
  capi_v1_tmp = array_from_pyobj(PyArray_DOUBLE,v1_Dims,v1_Rank,capi_v1_intent,v1_capi);
  if (capi_v1_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v1' of slalib.sla_dpav to C/Fortran array" );
  } else {
    v1 = (double *)(capi_v1_tmp->data);

  /* Processing variable v2 */
  v2_Dims[0]=3;
  capi_v2_intent |= F2PY_INTENT_IN;
  capi_v2_tmp = array_from_pyobj(PyArray_DOUBLE,v2_Dims,v2_Rank,capi_v2_intent,v2_capi);
  if (capi_v2_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `v2' of slalib.sla_dpav to C/Fortran array" );
  } else {
    v2 = (double *)(capi_v2_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_dpav,v1,v2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_dpav);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_v2_tmp!=v2_capi) {
    Py_XDECREF(capi_v2_tmp); }
  }  /*if (capi_v2_tmp == NULL) ... else of v2*/
  /* End of cleaning variable v2 */
  if((PyObject *)capi_v1_tmp!=v1_capi) {
    Py_XDECREF(capi_v1_tmp); }
  }  /*if (capi_v1_tmp == NULL) ... else of v1*/
  /* End of cleaning variable v1 */
  /* End of cleaning variable sla_dpav */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dpav ******************************/

/********************************* sla_dr2af *********************************/
static char doc_f2py_rout_slalib_sla_dr2af[] = "\
Function signature:\n\
  sign,idmsf = sla_dr2af(ndp,angle)\n\
Required arguments:\n"
"  ndp : input int\n"
"  angle : input float\n"
"Return objects:\n"
"  sign : string(len=1)\n"
"  idmsf : rank-1 array('i') with bounds (4)";
/* extern void F_FUNC_US(sla_dr2af,SLA_DR2AF)(int*,double*,string,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_dr2af(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,double*,string,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ndp = 0;
  PyObject *ndp_capi = Py_None;
  double angle = 0;
  PyObject *angle_capi = Py_None;
  string sign = NULL;
  int slen(sign);
  PyObject *sign_capi = Py_None;
  int *idmsf = NULL;
  npy_intp idmsf_Dims[1] = {-1};
  const int idmsf_Rank = 1;
  PyArrayObject *capi_idmsf_tmp = NULL;
  int capi_idmsf_intent = 0;
  static char *capi_kwlist[] = {"ndp","angle",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dr2af",\
    capi_kwlist,&ndp_capi,&angle_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ndp */
    f2py_success = int_from_pyobj(&ndp,ndp_capi,"slalib.sla_dr2af() 1st argument (ndp) can't be converted to int");
  if (f2py_success) {
  /* Processing variable idmsf */
  idmsf_Dims[0]=4;
  capi_idmsf_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_idmsf_tmp = array_from_pyobj(PyArray_INT,idmsf_Dims,idmsf_Rank,capi_idmsf_intent,Py_None);
  if (capi_idmsf_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `idmsf' of slalib.sla_dr2af to C/Fortran array" );
  } else {
    idmsf = (int *)(capi_idmsf_tmp->data);

  /* Processing variable angle */
    f2py_success = double_from_pyobj(&angle,angle_capi,"slalib.sla_dr2af() 2nd argument (angle) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sign */
  slen(sign) = 1;
  f2py_success = string_from_pyobj(&sign,&slen(sign),"",sign_capi,"string_from_pyobj failed in converting hidden `sign' of slalib.sla_dr2af to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ndp,&angle,sign,idmsf,slen(sign));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("zN",sign,capi_idmsf_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(sign);
  }  /*if (f2py_success) of sign*/
  /* End of cleaning variable sign */
  } /*if (f2py_success) of angle*/
  /* End of cleaning variable angle */
  }  /*if (capi_idmsf_tmp == NULL) ... else of idmsf*/
  /* End of cleaning variable idmsf */
  } /*if (f2py_success) of ndp*/
  /* End of cleaning variable ndp */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dr2af ******************************/

/********************************* sla_dr2tf *********************************/
static char doc_f2py_rout_slalib_sla_dr2tf[] = "\
Function signature:\n\
  sign,ihmsf = sla_dr2tf(ndp,angle)\n\
Required arguments:\n"
"  ndp : input int\n"
"  angle : input float\n"
"Return objects:\n"
"  sign : string(len=1)\n"
"  ihmsf : rank-1 array('i') with bounds (4)";
/* extern void F_FUNC_US(sla_dr2tf,SLA_DR2TF)(int*,double*,string,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_dr2tf(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,double*,string,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ndp = 0;
  PyObject *ndp_capi = Py_None;
  double angle = 0;
  PyObject *angle_capi = Py_None;
  string sign = NULL;
  int slen(sign);
  PyObject *sign_capi = Py_None;
  int *ihmsf = NULL;
  npy_intp ihmsf_Dims[1] = {-1};
  const int ihmsf_Rank = 1;
  PyArrayObject *capi_ihmsf_tmp = NULL;
  int capi_ihmsf_intent = 0;
  static char *capi_kwlist[] = {"ndp","angle",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dr2tf",\
    capi_kwlist,&ndp_capi,&angle_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ndp */
    f2py_success = int_from_pyobj(&ndp,ndp_capi,"slalib.sla_dr2tf() 1st argument (ndp) can't be converted to int");
  if (f2py_success) {
  /* Processing variable angle */
    f2py_success = double_from_pyobj(&angle,angle_capi,"slalib.sla_dr2tf() 2nd argument (angle) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ihmsf */
  ihmsf_Dims[0]=4;
  capi_ihmsf_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_ihmsf_tmp = array_from_pyobj(PyArray_INT,ihmsf_Dims,ihmsf_Rank,capi_ihmsf_intent,Py_None);
  if (capi_ihmsf_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `ihmsf' of slalib.sla_dr2tf to C/Fortran array" );
  } else {
    ihmsf = (int *)(capi_ihmsf_tmp->data);

  /* Processing variable sign */
  slen(sign) = 1;
  f2py_success = string_from_pyobj(&sign,&slen(sign),"",sign_capi,"string_from_pyobj failed in converting hidden `sign' of slalib.sla_dr2tf to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ndp,&angle,sign,ihmsf,slen(sign));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("zN",sign,capi_ihmsf_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(sign);
  }  /*if (f2py_success) of sign*/
  /* End of cleaning variable sign */
  }  /*if (capi_ihmsf_tmp == NULL) ... else of ihmsf*/
  /* End of cleaning variable ihmsf */
  } /*if (f2py_success) of angle*/
  /* End of cleaning variable angle */
  } /*if (f2py_success) of ndp*/
  /* End of cleaning variable ndp */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dr2tf ******************************/

/********************************* sla_drange *********************************/
static char doc_f2py_rout_slalib_sla_drange[] = "\
Function signature:\n\
  sla_drange = sla_drange(angle)\n\
Required arguments:\n"
"  angle : input float\n"
"Return objects:\n"
"  sla_drange : float";
/* extern void F_WRAPPEDFUNC_US(sla_drange,SLA_DRANGE)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_drange(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_drange = 0;
  double angle = 0;
  PyObject *angle_capi = Py_None;
  static char *capi_kwlist[] = {"angle",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_drange",\
    capi_kwlist,&angle_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable sla_drange */
  /* Processing variable angle */
    f2py_success = double_from_pyobj(&angle,angle_capi,"slalib.sla_drange() 1st argument (angle) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_drange,&angle);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_drange);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of angle*/
  /* End of cleaning variable angle */
  /* End of cleaning variable sla_drange */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_drange *****************************/

/********************************* sla_dranrm *********************************/
static char doc_f2py_rout_slalib_sla_dranrm[] = "\
Function signature:\n\
  sla_dranrm = sla_dranrm(angle)\n\
Required arguments:\n"
"  angle : input float\n"
"Return objects:\n"
"  sla_dranrm : float";
/* extern void F_WRAPPEDFUNC_US(sla_dranrm,SLA_DRANRM)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_dranrm(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_dranrm = 0;
  double angle = 0;
  PyObject *angle_capi = Py_None;
  static char *capi_kwlist[] = {"angle",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_dranrm",\
    capi_kwlist,&angle_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable angle */
    f2py_success = double_from_pyobj(&angle,angle_capi,"slalib.sla_dranrm() 1st argument (angle) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_dranrm */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_dranrm,&angle);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_dranrm);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_dranrm */
  } /*if (f2py_success) of angle*/
  /* End of cleaning variable angle */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_dranrm *****************************/

/********************************* sla_ds2c6 *********************************/
static char doc_f2py_rout_slalib_sla_ds2c6[] = "\
Function signature:\n\
  v = sla_ds2c6(a,b,r,ad,bd,rd)\n\
Required arguments:\n"
"  a : input float\n"
"  b : input float\n"
"  r : input float\n"
"  ad : input float\n"
"  bd : input float\n"
"  rd : input float\n"
"Return objects:\n"
"  v : rank-1 array('d') with bounds (6)";
/* extern void F_FUNC_US(sla_ds2c6,SLA_DS2C6)(double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_ds2c6(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double a = 0;
  PyObject *a_capi = Py_None;
  double b = 0;
  PyObject *b_capi = Py_None;
  double r = 0;
  PyObject *r_capi = Py_None;
  double ad = 0;
  PyObject *ad_capi = Py_None;
  double bd = 0;
  PyObject *bd_capi = Py_None;
  double rd = 0;
  PyObject *rd_capi = Py_None;
  double *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  static char *capi_kwlist[] = {"a","b","r","ad","bd","rd",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOO|:slalib.sla_ds2c6",\
    capi_kwlist,&a_capi,&b_capi,&r_capi,&ad_capi,&bd_capi,&rd_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
    f2py_success = double_from_pyobj(&a,a_capi,"slalib.sla_ds2c6() 1st argument (a) can't be converted to double");
  if (f2py_success) {
  /* Processing variable bd */
    f2py_success = double_from_pyobj(&bd,bd_capi,"slalib.sla_ds2c6() 5th argument (bd) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r */
    f2py_success = double_from_pyobj(&r,r_capi,"slalib.sla_ds2c6() 3rd argument (r) can't be converted to double");
  if (f2py_success) {
  /* Processing variable b */
    f2py_success = double_from_pyobj(&b,b_capi,"slalib.sla_ds2c6() 2nd argument (b) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ad */
    f2py_success = double_from_pyobj(&ad,ad_capi,"slalib.sla_ds2c6() 4th argument (ad) can't be converted to double");
  if (f2py_success) {
  /* Processing variable v */
  v_Dims[0]=6;
  capi_v_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_v_tmp = array_from_pyobj(PyArray_DOUBLE,v_Dims,v_Rank,capi_v_intent,Py_None);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `v' of slalib.sla_ds2c6 to C/Fortran array" );
  } else {
    v = (double *)(capi_v_tmp->data);

  /* Processing variable rd */
    f2py_success = double_from_pyobj(&rd,rd_capi,"slalib.sla_ds2c6() 6th argument (rd) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&a,&b,&r,&ad,&bd,&rd,v);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_v_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of rd*/
  /* End of cleaning variable rd */
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  } /*if (f2py_success) of ad*/
  /* End of cleaning variable ad */
  } /*if (f2py_success) of b*/
  /* End of cleaning variable b */
  } /*if (f2py_success) of r*/
  /* End of cleaning variable r */
  } /*if (f2py_success) of bd*/
  /* End of cleaning variable bd */
  } /*if (f2py_success) of a*/
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_ds2c6 ******************************/

/********************************* sla_ds2tp *********************************/
static char doc_f2py_rout_slalib_sla_ds2tp[] = "\
Function signature:\n\
  xi,eta,j = sla_ds2tp(ra,dec,raz,decz)\n\
Required arguments:\n"
"  ra : input float\n"
"  dec : input float\n"
"  raz : input float\n"
"  decz : input float\n"
"Return objects:\n"
"  xi : float\n"
"  eta : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_ds2tp,SLA_DS2TP)(double*,double*,double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_ds2tp(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double ra = 0;
  PyObject *ra_capi = Py_None;
  double dec = 0;
  PyObject *dec_capi = Py_None;
  double raz = 0;
  PyObject *raz_capi = Py_None;
  double decz = 0;
  PyObject *decz_capi = Py_None;
  double xi = 0;
  double eta = 0;
  int j = 0;
  static char *capi_kwlist[] = {"ra","dec","raz","decz",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_ds2tp",\
    capi_kwlist,&ra_capi,&dec_capi,&raz_capi,&decz_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable xi */
  /* Processing variable ra */
    f2py_success = double_from_pyobj(&ra,ra_capi,"slalib.sla_ds2tp() 1st argument (ra) can't be converted to double");
  if (f2py_success) {
  /* Processing variable decz */
    f2py_success = double_from_pyobj(&decz,decz_capi,"slalib.sla_ds2tp() 4th argument (decz) can't be converted to double");
  if (f2py_success) {
  /* Processing variable eta */
  /* Processing variable raz */
    f2py_success = double_from_pyobj(&raz,raz_capi,"slalib.sla_ds2tp() 3rd argument (raz) can't be converted to double");
  if (f2py_success) {
  /* Processing variable j */
  /* Processing variable dec */
    f2py_success = double_from_pyobj(&dec,dec_capi,"slalib.sla_ds2tp() 2nd argument (dec) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ra,&dec,&raz,&decz,&xi,&eta,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ddi",xi,eta,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of dec*/
  /* End of cleaning variable dec */
  /* End of cleaning variable j */
  } /*if (f2py_success) of raz*/
  /* End of cleaning variable raz */
  /* End of cleaning variable eta */
  } /*if (f2py_success) of decz*/
  /* End of cleaning variable decz */
  } /*if (f2py_success) of ra*/
  /* End of cleaning variable ra */
  /* End of cleaning variable xi */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_ds2tp ******************************/

/********************************** sla_dsep **********************************/
static char doc_f2py_rout_slalib_sla_dsep[] = "\
Function signature:\n\
  sla_dsep = sla_dsep(a1,b1,a2,b2)\n\
Required arguments:\n"
"  a1 : input float\n"
"  b1 : input float\n"
"  a2 : input float\n"
"  b2 : input float\n"
"Return objects:\n"
"  sla_dsep : float";
/* extern void F_WRAPPEDFUNC_US(sla_dsep,SLA_DSEP)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dsep(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_dsep = 0;
  double a1 = 0;
  PyObject *a1_capi = Py_None;
  double b1 = 0;
  PyObject *b1_capi = Py_None;
  double a2 = 0;
  PyObject *a2_capi = Py_None;
  double b2 = 0;
  PyObject *b2_capi = Py_None;
  static char *capi_kwlist[] = {"a1","b1","a2","b2",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_dsep",\
    capi_kwlist,&a1_capi,&b1_capi,&a2_capi,&b2_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a1 */
    f2py_success = double_from_pyobj(&a1,a1_capi,"slalib.sla_dsep() 1st argument (a1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_dsep */
  /* Processing variable a2 */
    f2py_success = double_from_pyobj(&a2,a2_capi,"slalib.sla_dsep() 3rd argument (a2) can't be converted to double");
  if (f2py_success) {
  /* Processing variable b1 */
    f2py_success = double_from_pyobj(&b1,b1_capi,"slalib.sla_dsep() 2nd argument (b1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable b2 */
    f2py_success = double_from_pyobj(&b2,b2_capi,"slalib.sla_dsep() 4th argument (b2) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_dsep,&a1,&b1,&a2,&b2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_dsep);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of b2*/
  /* End of cleaning variable b2 */
  } /*if (f2py_success) of b1*/
  /* End of cleaning variable b1 */
  } /*if (f2py_success) of a2*/
  /* End of cleaning variable a2 */
  /* End of cleaning variable sla_dsep */
  } /*if (f2py_success) of a1*/
  /* End of cleaning variable a1 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dsep ******************************/

/********************************* sla_dsepv *********************************/
static char doc_f2py_rout_slalib_sla_dsepv[] = "\
Function signature:\n\
  sla_dsepv = sla_dsepv(v1,v2)\n\
Required arguments:\n"
"  v1 : input rank-1 array('d') with bounds (3)\n"
"  v2 : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  sla_dsepv : float";
/* extern void F_WRAPPEDFUNC_US(sla_dsepv,SLA_DSEPV)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dsepv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_dsepv = 0;
  double *v1 = NULL;
  npy_intp v1_Dims[1] = {-1};
  const int v1_Rank = 1;
  PyArrayObject *capi_v1_tmp = NULL;
  int capi_v1_intent = 0;
  PyObject *v1_capi = Py_None;
  double *v2 = NULL;
  npy_intp v2_Dims[1] = {-1};
  const int v2_Rank = 1;
  PyArrayObject *capi_v2_tmp = NULL;
  int capi_v2_intent = 0;
  PyObject *v2_capi = Py_None;
  static char *capi_kwlist[] = {"v1","v2",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dsepv",\
    capi_kwlist,&v1_capi,&v2_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable v1 */
  v1_Dims[0]=3;
  capi_v1_intent |= F2PY_INTENT_IN;
  capi_v1_tmp = array_from_pyobj(PyArray_DOUBLE,v1_Dims,v1_Rank,capi_v1_intent,v1_capi);
  if (capi_v1_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v1' of slalib.sla_dsepv to C/Fortran array" );
  } else {
    v1 = (double *)(capi_v1_tmp->data);

  /* Processing variable v2 */
  v2_Dims[0]=3;
  capi_v2_intent |= F2PY_INTENT_IN;
  capi_v2_tmp = array_from_pyobj(PyArray_DOUBLE,v2_Dims,v2_Rank,capi_v2_intent,v2_capi);
  if (capi_v2_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `v2' of slalib.sla_dsepv to C/Fortran array" );
  } else {
    v2 = (double *)(capi_v2_tmp->data);

  /* Processing variable sla_dsepv */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_dsepv,v1,v2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_dsepv);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_dsepv */
  if((PyObject *)capi_v2_tmp!=v2_capi) {
    Py_XDECREF(capi_v2_tmp); }
  }  /*if (capi_v2_tmp == NULL) ... else of v2*/
  /* End of cleaning variable v2 */
  if((PyObject *)capi_v1_tmp!=v1_capi) {
    Py_XDECREF(capi_v1_tmp); }
  }  /*if (capi_v1_tmp == NULL) ... else of v1*/
  /* End of cleaning variable v1 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dsepv ******************************/

/*********************************** sla_dt ***********************************/
static char doc_f2py_rout_slalib_sla_dt[] = "\
Function signature:\n\
  sla_dt = sla_dt(epoch)\n\
Required arguments:\n"
"  epoch : input float\n"
"Return objects:\n"
"  sla_dt : float";
/* extern void F_WRAPPEDFUNC_US(sla_dt,SLA_DT)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_dt(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_dt = 0;
  double epoch = 0;
  PyObject *epoch_capi = Py_None;
  static char *capi_kwlist[] = {"epoch",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_dt",\
    capi_kwlist,&epoch_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable epoch */
    f2py_success = double_from_pyobj(&epoch,epoch_capi,"slalib.sla_dt() 1st argument (epoch) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_dt */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_dt,&epoch);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_dt);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_dt */
  } /*if (f2py_success) of epoch*/
  /* End of cleaning variable epoch */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_dt *******************************/

/********************************* sla_dtf2d *********************************/
static char doc_f2py_rout_slalib_sla_dtf2d[] = "\
Function signature:\n\
  days,j = sla_dtf2d(ihour,imin,sec)\n\
Required arguments:\n"
"  ihour : input int\n"
"  imin : input int\n"
"  sec : input float\n"
"Return objects:\n"
"  days : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_dtf2d,SLA_DTF2D)(int*,int*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_dtf2d(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ihour = 0;
  PyObject *ihour_capi = Py_None;
  int imin = 0;
  PyObject *imin_capi = Py_None;
  double sec = 0;
  PyObject *sec_capi = Py_None;
  double days = 0;
  int j = 0;
  static char *capi_kwlist[] = {"ihour","imin","sec",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_dtf2d",\
    capi_kwlist,&ihour_capi,&imin_capi,&sec_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ihour */
    f2py_success = int_from_pyobj(&ihour,ihour_capi,"slalib.sla_dtf2d() 1st argument (ihour) can't be converted to int");
  if (f2py_success) {
  /* Processing variable imin */
    f2py_success = int_from_pyobj(&imin,imin_capi,"slalib.sla_dtf2d() 2nd argument (imin) can't be converted to int");
  if (f2py_success) {
  /* Processing variable sec */
    f2py_success = double_from_pyobj(&sec,sec_capi,"slalib.sla_dtf2d() 3rd argument (sec) can't be converted to double");
  if (f2py_success) {
  /* Processing variable days */
  /* Processing variable j */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ihour,&imin,&sec,&days,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("di",days,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable j */
  /* End of cleaning variable days */
  } /*if (f2py_success) of sec*/
  /* End of cleaning variable sec */
  } /*if (f2py_success) of imin*/
  /* End of cleaning variable imin */
  } /*if (f2py_success) of ihour*/
  /* End of cleaning variable ihour */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dtf2d ******************************/

/********************************* sla_dtf2r *********************************/
static char doc_f2py_rout_slalib_sla_dtf2r[] = "\
Function signature:\n\
  rad,j = sla_dtf2r(ihour,imin,sec)\n\
Required arguments:\n"
"  ihour : input int\n"
"  imin : input int\n"
"  sec : input float\n"
"Return objects:\n"
"  rad : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_dtf2r,SLA_DTF2R)(int*,int*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_dtf2r(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int ihour = 0;
  PyObject *ihour_capi = Py_None;
  int imin = 0;
  PyObject *imin_capi = Py_None;
  double sec = 0;
  PyObject *sec_capi = Py_None;
  double rad = 0;
  int j = 0;
  static char *capi_kwlist[] = {"ihour","imin","sec",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_dtf2r",\
    capi_kwlist,&ihour_capi,&imin_capi,&sec_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ihour */
    f2py_success = int_from_pyobj(&ihour,ihour_capi,"slalib.sla_dtf2r() 1st argument (ihour) can't be converted to int");
  if (f2py_success) {
  /* Processing variable imin */
    f2py_success = int_from_pyobj(&imin,imin_capi,"slalib.sla_dtf2r() 2nd argument (imin) can't be converted to int");
  if (f2py_success) {
  /* Processing variable sec */
    f2py_success = double_from_pyobj(&sec,sec_capi,"slalib.sla_dtf2r() 3rd argument (sec) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rad */
  /* Processing variable j */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ihour,&imin,&sec,&rad,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("di",rad,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable j */
  /* End of cleaning variable rad */
  } /*if (f2py_success) of sec*/
  /* End of cleaning variable sec */
  } /*if (f2py_success) of imin*/
  /* End of cleaning variable imin */
  } /*if (f2py_success) of ihour*/
  /* End of cleaning variable ihour */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dtf2r ******************************/

/********************************* sla_dtp2s *********************************/
static char doc_f2py_rout_slalib_sla_dtp2s[] = "\
Function signature:\n\
  ra,dec = sla_dtp2s(xi,eta,raz,decz)\n\
Required arguments:\n"
"  xi : input float\n"
"  eta : input float\n"
"  raz : input float\n"
"  decz : input float\n"
"Return objects:\n"
"  ra : float\n"
"  dec : float";
/* extern void F_FUNC_US(sla_dtp2s,SLA_DTP2S)(double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dtp2s(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double xi = 0;
  PyObject *xi_capi = Py_None;
  double eta = 0;
  PyObject *eta_capi = Py_None;
  double raz = 0;
  PyObject *raz_capi = Py_None;
  double decz = 0;
  PyObject *decz_capi = Py_None;
  double ra = 0;
  double dec = 0;
  static char *capi_kwlist[] = {"xi","eta","raz","decz",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_dtp2s",\
    capi_kwlist,&xi_capi,&eta_capi,&raz_capi,&decz_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable xi */
    f2py_success = double_from_pyobj(&xi,xi_capi,"slalib.sla_dtp2s() 1st argument (xi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ra */
  /* Processing variable decz */
    f2py_success = double_from_pyobj(&decz,decz_capi,"slalib.sla_dtp2s() 4th argument (decz) can't be converted to double");
  if (f2py_success) {
  /* Processing variable eta */
    f2py_success = double_from_pyobj(&eta,eta_capi,"slalib.sla_dtp2s() 2nd argument (eta) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dec */
  /* Processing variable raz */
    f2py_success = double_from_pyobj(&raz,raz_capi,"slalib.sla_dtp2s() 3rd argument (raz) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&xi,&eta,&raz,&decz,&ra,&dec);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",ra,dec);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of raz*/
  /* End of cleaning variable raz */
  /* End of cleaning variable dec */
  } /*if (f2py_success) of eta*/
  /* End of cleaning variable eta */
  } /*if (f2py_success) of decz*/
  /* End of cleaning variable decz */
  /* End of cleaning variable ra */
  } /*if (f2py_success) of xi*/
  /* End of cleaning variable xi */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dtp2s ******************************/

/********************************* sla_dtp2v *********************************/
static char doc_f2py_rout_slalib_sla_dtp2v[] = "\
Function signature:\n\
  v = sla_dtp2v(xi,eta,v0)\n\
Required arguments:\n"
"  xi : input float\n"
"  eta : input float\n"
"  v0 : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  v : rank-1 array('d') with bounds (3)";
/* extern void F_FUNC_US(sla_dtp2v,SLA_DTP2V)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dtp2v(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double xi = 0;
  PyObject *xi_capi = Py_None;
  double eta = 0;
  PyObject *eta_capi = Py_None;
  double *v0 = NULL;
  npy_intp v0_Dims[1] = {-1};
  const int v0_Rank = 1;
  PyArrayObject *capi_v0_tmp = NULL;
  int capi_v0_intent = 0;
  PyObject *v0_capi = Py_None;
  double *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  static char *capi_kwlist[] = {"xi","eta","v0",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_dtp2v",\
    capi_kwlist,&xi_capi,&eta_capi,&v0_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable v0 */
  v0_Dims[0]=3;
  capi_v0_intent |= F2PY_INTENT_IN;
  capi_v0_tmp = array_from_pyobj(PyArray_DOUBLE,v0_Dims,v0_Rank,capi_v0_intent,v0_capi);
  if (capi_v0_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `v0' of slalib.sla_dtp2v to C/Fortran array" );
  } else {
    v0 = (double *)(capi_v0_tmp->data);

  /* Processing variable eta */
    f2py_success = double_from_pyobj(&eta,eta_capi,"slalib.sla_dtp2v() 2nd argument (eta) can't be converted to double");
  if (f2py_success) {
  /* Processing variable xi */
    f2py_success = double_from_pyobj(&xi,xi_capi,"slalib.sla_dtp2v() 1st argument (xi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_v_tmp = array_from_pyobj(PyArray_DOUBLE,v_Dims,v_Rank,capi_v_intent,Py_None);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `v' of slalib.sla_dtp2v to C/Fortran array" );
  } else {
    v = (double *)(capi_v_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&xi,&eta,v0,v);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_v_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  } /*if (f2py_success) of xi*/
  /* End of cleaning variable xi */
  } /*if (f2py_success) of eta*/
  /* End of cleaning variable eta */
  if((PyObject *)capi_v0_tmp!=v0_capi) {
    Py_XDECREF(capi_v0_tmp); }
  }  /*if (capi_v0_tmp == NULL) ... else of v0*/
  /* End of cleaning variable v0 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dtp2v ******************************/

/********************************* sla_dtps2c *********************************/
static char doc_f2py_rout_slalib_sla_dtps2c[] = "\
Function signature:\n\
  raz1,decz1,raz2,decz2,n = sla_dtps2c(xi,eta,ra,dec)\n\
Required arguments:\n"
"  xi : input float\n"
"  eta : input float\n"
"  ra : input float\n"
"  dec : input float\n"
"Return objects:\n"
"  raz1 : float\n"
"  decz1 : float\n"
"  raz2 : float\n"
"  decz2 : float\n"
"  n : int";
/* extern void F_FUNC_US(sla_dtps2c,SLA_DTPS2C)(double*,double*,double*,double*,double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_dtps2c(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double xi = 0;
  PyObject *xi_capi = Py_None;
  double eta = 0;
  PyObject *eta_capi = Py_None;
  double ra = 0;
  PyObject *ra_capi = Py_None;
  double dec = 0;
  PyObject *dec_capi = Py_None;
  double raz1 = 0;
  double decz1 = 0;
  double raz2 = 0;
  double decz2 = 0;
  int n = 0;
  static char *capi_kwlist[] = {"xi","eta","ra","dec",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_dtps2c",\
    capi_kwlist,&xi_capi,&eta_capi,&ra_capi,&dec_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable decz2 */
  /* Processing variable decz1 */
  /* Processing variable xi */
    f2py_success = double_from_pyobj(&xi,xi_capi,"slalib.sla_dtps2c() 1st argument (xi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable raz1 */
  /* Processing variable raz2 */
  /* Processing variable n */
  /* Processing variable eta */
    f2py_success = double_from_pyobj(&eta,eta_capi,"slalib.sla_dtps2c() 2nd argument (eta) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ra */
    f2py_success = double_from_pyobj(&ra,ra_capi,"slalib.sla_dtps2c() 3rd argument (ra) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dec */
    f2py_success = double_from_pyobj(&dec,dec_capi,"slalib.sla_dtps2c() 4th argument (dec) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&xi,&eta,&ra,&dec,&raz1,&decz1,&raz2,&decz2,&n);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ddddi",raz1,decz1,raz2,decz2,n);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of dec*/
  /* End of cleaning variable dec */
  } /*if (f2py_success) of ra*/
  /* End of cleaning variable ra */
  } /*if (f2py_success) of eta*/
  /* End of cleaning variable eta */
  /* End of cleaning variable n */
  /* End of cleaning variable raz2 */
  /* End of cleaning variable raz1 */
  } /*if (f2py_success) of xi*/
  /* End of cleaning variable xi */
  /* End of cleaning variable decz1 */
  /* End of cleaning variable decz2 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_dtps2c *****************************/

/********************************* sla_dtpv2c *********************************/
static char doc_f2py_rout_slalib_sla_dtpv2c[] = "\
Function signature:\n\
  v01,v02,n = sla_dtpv2c(xi,eta,v)\n\
Required arguments:\n"
"  xi : input float\n"
"  eta : input float\n"
"  v : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  v01 : rank-1 array('d') with bounds (3)\n"
"  v02 : rank-1 array('d') with bounds (3)\n"
"  n : int";
/* extern void F_FUNC_US(sla_dtpv2c,SLA_DTPV2C)(double*,double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_dtpv2c(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double xi = 0;
  PyObject *xi_capi = Py_None;
  double eta = 0;
  PyObject *eta_capi = Py_None;
  double *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  double *v01 = NULL;
  npy_intp v01_Dims[1] = {-1};
  const int v01_Rank = 1;
  PyArrayObject *capi_v01_tmp = NULL;
  int capi_v01_intent = 0;
  double *v02 = NULL;
  npy_intp v02_Dims[1] = {-1};
  const int v02_Rank = 1;
  PyArrayObject *capi_v02_tmp = NULL;
  int capi_v02_intent = 0;
  int n = 0;
  static char *capi_kwlist[] = {"xi","eta","v",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_dtpv2c",\
    capi_kwlist,&xi_capi,&eta_capi,&v_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable xi */
    f2py_success = double_from_pyobj(&xi,xi_capi,"slalib.sla_dtpv2c() 1st argument (xi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable v01 */
  v01_Dims[0]=3;
  capi_v01_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_v01_tmp = array_from_pyobj(PyArray_DOUBLE,v01_Dims,v01_Rank,capi_v01_intent,Py_None);
  if (capi_v01_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `v01' of slalib.sla_dtpv2c to C/Fortran array" );
  } else {
    v01 = (double *)(capi_v01_tmp->data);

  /* Processing variable v02 */
  v02_Dims[0]=3;
  capi_v02_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_v02_tmp = array_from_pyobj(PyArray_DOUBLE,v02_Dims,v02_Rank,capi_v02_intent,Py_None);
  if (capi_v02_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `v02' of slalib.sla_dtpv2c to C/Fortran array" );
  } else {
    v02 = (double *)(capi_v02_tmp->data);

  /* Processing variable eta */
    f2py_success = double_from_pyobj(&eta,eta_capi,"slalib.sla_dtpv2c() 2nd argument (eta) can't be converted to double");
  if (f2py_success) {
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_DOUBLE,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `v' of slalib.sla_dtpv2c to C/Fortran array" );
  } else {
    v = (double *)(capi_v_tmp->data);

  /* Processing variable n */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&xi,&eta,v,v01,v02,&n);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("NNi",capi_v01_tmp,capi_v02_tmp,n);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable n */
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  } /*if (f2py_success) of eta*/
  /* End of cleaning variable eta */
  }  /*if (capi_v02_tmp == NULL) ... else of v02*/
  /* End of cleaning variable v02 */
  }  /*if (capi_v01_tmp == NULL) ... else of v01*/
  /* End of cleaning variable v01 */
  } /*if (f2py_success) of xi*/
  /* End of cleaning variable xi */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_dtpv2c *****************************/

/********************************** sla_dtt **********************************/
static char doc_f2py_rout_slalib_sla_dtt[] = "\
Function signature:\n\
  sla_dtt = sla_dtt(utc)\n\
Required arguments:\n"
"  utc : input float\n"
"Return objects:\n"
"  sla_dtt : float";
/* extern void F_WRAPPEDFUNC_US(sla_dtt,SLA_DTT)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_dtt(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_dtt = 0;
  double utc = 0;
  PyObject *utc_capi = Py_None;
  static char *capi_kwlist[] = {"utc",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_dtt",\
    capi_kwlist,&utc_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable utc */
    f2py_success = double_from_pyobj(&utc,utc_capi,"slalib.sla_dtt() 1st argument (utc) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_dtt */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_dtt,&utc);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_dtt);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_dtt */
  } /*if (f2py_success) of utc*/
  /* End of cleaning variable utc */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_dtt *******************************/

/********************************* sla_dv2tp *********************************/
static char doc_f2py_rout_slalib_sla_dv2tp[] = "\
Function signature:\n\
  xi,eta,j = sla_dv2tp(v,v0)\n\
Required arguments:\n"
"  v : input rank-1 array('d') with bounds (3)\n"
"  v0 : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  xi : float\n"
"  eta : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_dv2tp,SLA_DV2TP)(double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_dv2tp(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  double *v0 = NULL;
  npy_intp v0_Dims[1] = {-1};
  const int v0_Rank = 1;
  PyArrayObject *capi_v0_tmp = NULL;
  int capi_v0_intent = 0;
  PyObject *v0_capi = Py_None;
  double xi = 0;
  double eta = 0;
  int j = 0;
  static char *capi_kwlist[] = {"v","v0",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dv2tp",\
    capi_kwlist,&v_capi,&v0_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable v0 */
  v0_Dims[0]=3;
  capi_v0_intent |= F2PY_INTENT_IN;
  capi_v0_tmp = array_from_pyobj(PyArray_DOUBLE,v0_Dims,v0_Rank,capi_v0_intent,v0_capi);
  if (capi_v0_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `v0' of slalib.sla_dv2tp to C/Fortran array" );
  } else {
    v0 = (double *)(capi_v0_tmp->data);

  /* Processing variable eta */
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_DOUBLE,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v' of slalib.sla_dv2tp to C/Fortran array" );
  } else {
    v = (double *)(capi_v_tmp->data);

  /* Processing variable xi */
  /* Processing variable j */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(v,v0,&xi,&eta,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ddi",xi,eta,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable j */
  /* End of cleaning variable xi */
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  /* End of cleaning variable eta */
  if((PyObject *)capi_v0_tmp!=v0_capi) {
    Py_XDECREF(capi_v0_tmp); }
  }  /*if (capi_v0_tmp == NULL) ... else of v0*/
  /* End of cleaning variable v0 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dv2tp ******************************/

/********************************** sla_dvdv **********************************/
static char doc_f2py_rout_slalib_sla_dvdv[] = "\
Function signature:\n\
  sla_dvdv = sla_dvdv(va,vb)\n\
Required arguments:\n"
"  va : input rank-1 array('d') with bounds (3)\n"
"  vb : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  sla_dvdv : float";
/* extern void F_WRAPPEDFUNC_US(sla_dvdv,SLA_DVDV)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dvdv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_dvdv = 0;
  double *va = NULL;
  npy_intp va_Dims[1] = {-1};
  const int va_Rank = 1;
  PyArrayObject *capi_va_tmp = NULL;
  int capi_va_intent = 0;
  PyObject *va_capi = Py_None;
  double *vb = NULL;
  npy_intp vb_Dims[1] = {-1};
  const int vb_Rank = 1;
  PyArrayObject *capi_vb_tmp = NULL;
  int capi_vb_intent = 0;
  PyObject *vb_capi = Py_None;
  static char *capi_kwlist[] = {"va","vb",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dvdv",\
    capi_kwlist,&va_capi,&vb_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable va */
  va_Dims[0]=3;
  capi_va_intent |= F2PY_INTENT_IN;
  capi_va_tmp = array_from_pyobj(PyArray_DOUBLE,va_Dims,va_Rank,capi_va_intent,va_capi);
  if (capi_va_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `va' of slalib.sla_dvdv to C/Fortran array" );
  } else {
    va = (double *)(capi_va_tmp->data);

  /* Processing variable vb */
  vb_Dims[0]=3;
  capi_vb_intent |= F2PY_INTENT_IN;
  capi_vb_tmp = array_from_pyobj(PyArray_DOUBLE,vb_Dims,vb_Rank,capi_vb_intent,vb_capi);
  if (capi_vb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `vb' of slalib.sla_dvdv to C/Fortran array" );
  } else {
    vb = (double *)(capi_vb_tmp->data);

  /* Processing variable sla_dvdv */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_dvdv,va,vb);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_dvdv);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_dvdv */
  if((PyObject *)capi_vb_tmp!=vb_capi) {
    Py_XDECREF(capi_vb_tmp); }
  }  /*if (capi_vb_tmp == NULL) ... else of vb*/
  /* End of cleaning variable vb */
  if((PyObject *)capi_va_tmp!=va_capi) {
    Py_XDECREF(capi_va_tmp); }
  }  /*if (capi_va_tmp == NULL) ... else of va*/
  /* End of cleaning variable va */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dvdv ******************************/

/********************************** sla_dvn **********************************/
static char doc_f2py_rout_slalib_sla_dvn[] = "\
Function signature:\n\
  uv,vm = sla_dvn(v)\n\
Required arguments:\n"
"  v : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  uv : rank-1 array('d') with bounds (3)\n"
"  vm : float";
/* extern void F_FUNC_US(sla_dvn,SLA_DVN)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dvn(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  double *uv = NULL;
  npy_intp uv_Dims[1] = {-1};
  const int uv_Rank = 1;
  PyArrayObject *capi_uv_tmp = NULL;
  int capi_uv_intent = 0;
  double vm = 0;
  static char *capi_kwlist[] = {"v",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_dvn",\
    capi_kwlist,&v_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable uv */
  uv_Dims[0]=3;
  capi_uv_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_uv_tmp = array_from_pyobj(PyArray_DOUBLE,uv_Dims,uv_Rank,capi_uv_intent,Py_None);
  if (capi_uv_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `uv' of slalib.sla_dvn to C/Fortran array" );
  } else {
    uv = (double *)(capi_uv_tmp->data);

  /* Processing variable vm */
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_DOUBLE,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v' of slalib.sla_dvn to C/Fortran array" );
  } else {
    v = (double *)(capi_v_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(v,uv,&vm);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Nd",capi_uv_tmp,vm);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  /* End of cleaning variable vm */
  }  /*if (capi_uv_tmp == NULL) ... else of uv*/
  /* End of cleaning variable uv */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_dvn *******************************/

/********************************** sla_dvxv **********************************/
static char doc_f2py_rout_slalib_sla_dvxv[] = "\
Function signature:\n\
  vc = sla_dvxv(va,vb)\n\
Required arguments:\n"
"  va : input rank-1 array('d') with bounds (3)\n"
"  vb : input rank-1 array('d') with bounds (3)\n"
"Return objects:\n"
"  vc : rank-1 array('d') with bounds (3)";
/* extern void F_FUNC_US(sla_dvxv,SLA_DVXV)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_dvxv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *va = NULL;
  npy_intp va_Dims[1] = {-1};
  const int va_Rank = 1;
  PyArrayObject *capi_va_tmp = NULL;
  int capi_va_intent = 0;
  PyObject *va_capi = Py_None;
  double *vb = NULL;
  npy_intp vb_Dims[1] = {-1};
  const int vb_Rank = 1;
  PyArrayObject *capi_vb_tmp = NULL;
  int capi_vb_intent = 0;
  PyObject *vb_capi = Py_None;
  double *vc = NULL;
  npy_intp vc_Dims[1] = {-1};
  const int vc_Rank = 1;
  PyArrayObject *capi_vc_tmp = NULL;
  int capi_vc_intent = 0;
  static char *capi_kwlist[] = {"va","vb",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_dvxv",\
    capi_kwlist,&va_capi,&vb_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable va */
  va_Dims[0]=3;
  capi_va_intent |= F2PY_INTENT_IN;
  capi_va_tmp = array_from_pyobj(PyArray_DOUBLE,va_Dims,va_Rank,capi_va_intent,va_capi);
  if (capi_va_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `va' of slalib.sla_dvxv to C/Fortran array" );
  } else {
    va = (double *)(capi_va_tmp->data);

  /* Processing variable vb */
  vb_Dims[0]=3;
  capi_vb_intent |= F2PY_INTENT_IN;
  capi_vb_tmp = array_from_pyobj(PyArray_DOUBLE,vb_Dims,vb_Rank,capi_vb_intent,vb_capi);
  if (capi_vb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `vb' of slalib.sla_dvxv to C/Fortran array" );
  } else {
    vb = (double *)(capi_vb_tmp->data);

  /* Processing variable vc */
  vc_Dims[0]=3;
  capi_vc_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_vc_tmp = array_from_pyobj(PyArray_DOUBLE,vc_Dims,vc_Rank,capi_vc_intent,Py_None);
  if (capi_vc_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `vc' of slalib.sla_dvxv to C/Fortran array" );
  } else {
    vc = (double *)(capi_vc_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(va,vb,vc);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_vc_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_vc_tmp == NULL) ... else of vc*/
  /* End of cleaning variable vc */
  if((PyObject *)capi_vb_tmp!=vb_capi) {
    Py_XDECREF(capi_vb_tmp); }
  }  /*if (capi_vb_tmp == NULL) ... else of vb*/
  /* End of cleaning variable vb */
  if((PyObject *)capi_va_tmp!=va_capi) {
    Py_XDECREF(capi_va_tmp); }
  }  /*if (capi_va_tmp == NULL) ... else of va*/
  /* End of cleaning variable va */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_dvxv ******************************/

/********************************** sla_e2h **********************************/
static char doc_f2py_rout_slalib_sla_e2h[] = "\
Function signature:\n\
  az,el = sla_e2h(ha,dec,phi)\n\
Required arguments:\n"
"  ha : input float\n"
"  dec : input float\n"
"  phi : input float\n"
"Return objects:\n"
"  az : float\n"
"  el : float";
/* extern void F_FUNC_US(sla_e2h,SLA_E2H)(float*,float*,float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_e2h(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float ha = 0;
  PyObject *ha_capi = Py_None;
  float dec = 0;
  PyObject *dec_capi = Py_None;
  float phi = 0;
  PyObject *phi_capi = Py_None;
  float az = 0;
  float el = 0;
  static char *capi_kwlist[] = {"ha","dec","phi",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_e2h",\
    capi_kwlist,&ha_capi,&dec_capi,&phi_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ha */
    f2py_success = float_from_pyobj(&ha,ha_capi,"slalib.sla_e2h() 1st argument (ha) can't be converted to float");
  if (f2py_success) {
  /* Processing variable el */
  /* Processing variable phi */
    f2py_success = float_from_pyobj(&phi,phi_capi,"slalib.sla_e2h() 3rd argument (phi) can't be converted to float");
  if (f2py_success) {
  /* Processing variable az */
  /* Processing variable dec */
    f2py_success = float_from_pyobj(&dec,dec_capi,"slalib.sla_e2h() 2nd argument (dec) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ha,&dec,&phi,&az,&el);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ff",az,el);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of dec*/
  /* End of cleaning variable dec */
  /* End of cleaning variable az */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
  /* End of cleaning variable el */
  } /*if (f2py_success) of ha*/
  /* End of cleaning variable ha */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_e2h *******************************/

/********************************* sla_earth *********************************/
static char doc_f2py_rout_slalib_sla_earth[] = "\
Function signature:\n\
  pv = sla_earth(iy,id,fd)\n\
Required arguments:\n"
"  iy : input int\n"
"  id : input int\n"
"  fd : input float\n"
"Return objects:\n"
"  pv : rank-1 array('f') with bounds (6)";
/* extern void F_FUNC_US(sla_earth,SLA_EARTH)(int*,int*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_earth(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int iy = 0;
  PyObject *iy_capi = Py_None;
  int id = 0;
  PyObject *id_capi = Py_None;
  float fd = 0;
  PyObject *fd_capi = Py_None;
  float *pv = NULL;
  npy_intp pv_Dims[1] = {-1};
  const int pv_Rank = 1;
  PyArrayObject *capi_pv_tmp = NULL;
  int capi_pv_intent = 0;
  static char *capi_kwlist[] = {"iy","id","fd",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_earth",\
    capi_kwlist,&iy_capi,&id_capi,&fd_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable iy */
    f2py_success = int_from_pyobj(&iy,iy_capi,"slalib.sla_earth() 1st argument (iy) can't be converted to int");
  if (f2py_success) {
  /* Processing variable fd */
    f2py_success = float_from_pyobj(&fd,fd_capi,"slalib.sla_earth() 3rd argument (fd) can't be converted to float");
  if (f2py_success) {
  /* Processing variable pv */
  pv_Dims[0]=6;
  capi_pv_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_pv_tmp = array_from_pyobj(PyArray_FLOAT,pv_Dims,pv_Rank,capi_pv_intent,Py_None);
  if (capi_pv_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `pv' of slalib.sla_earth to C/Fortran array" );
  } else {
    pv = (float *)(capi_pv_tmp->data);

  /* Processing variable id */
    f2py_success = int_from_pyobj(&id,id_capi,"slalib.sla_earth() 2nd argument (id) can't be converted to int");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&iy,&id,&fd,pv);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_pv_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of id*/
  /* End of cleaning variable id */
  }  /*if (capi_pv_tmp == NULL) ... else of pv*/
  /* End of cleaning variable pv */
  } /*if (f2py_success) of fd*/
  /* End of cleaning variable fd */
  } /*if (f2py_success) of iy*/
  /* End of cleaning variable iy */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_earth ******************************/

/********************************* sla_ecleq *********************************/
static char doc_f2py_rout_slalib_sla_ecleq[] = "\
Function signature:\n\
  dr,dd = sla_ecleq(dl,db,date)\n\
Required arguments:\n"
"  dl : input float\n"
"  db : input float\n"
"  date : input float\n"
"Return objects:\n"
"  dr : float\n"
"  dd : float";
/* extern void F_FUNC_US(sla_ecleq,SLA_ECLEQ)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_ecleq(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double dl = 0;
  PyObject *dl_capi = Py_None;
  double db = 0;
  PyObject *db_capi = Py_None;
  double date = 0;
  PyObject *date_capi = Py_None;
  double dr = 0;
  double dd = 0;
  static char *capi_kwlist[] = {"dl","db","date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_ecleq",\
    capi_kwlist,&dl_capi,&db_capi,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_ecleq() 3rd argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable db */
    f2py_success = double_from_pyobj(&db,db_capi,"slalib.sla_ecleq() 2nd argument (db) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dl */
    f2py_success = double_from_pyobj(&dl,dl_capi,"slalib.sla_ecleq() 1st argument (dl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dr */
  /* Processing variable dd */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&dl,&db,&date,&dr,&dd);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",dr,dd);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dd */
  /* End of cleaning variable dr */
  } /*if (f2py_success) of dl*/
  /* End of cleaning variable dl */
  } /*if (f2py_success) of db*/
  /* End of cleaning variable db */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_ecleq ******************************/

/********************************* sla_ecmat *********************************/
static char doc_f2py_rout_slalib_sla_ecmat[] = "\
Function signature:\n\
  rmat = sla_ecmat(date)\n\
Required arguments:\n"
"  date : input float\n"
"Return objects:\n"
"  rmat : rank-2 array('d') with bounds (3,3)";
/* extern void F_FUNC_US(sla_ecmat,SLA_ECMAT)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_ecmat(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double *rmat = NULL;
  npy_intp rmat_Dims[2] = {-1, -1};
  const int rmat_Rank = 2;
  PyArrayObject *capi_rmat_tmp = NULL;
  int capi_rmat_intent = 0;
  static char *capi_kwlist[] = {"date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_ecmat",\
    capi_kwlist,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_ecmat() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rmat */
  rmat_Dims[0]=3,rmat_Dims[1]=3;
  capi_rmat_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_rmat_tmp = array_from_pyobj(PyArray_DOUBLE,rmat_Dims,rmat_Rank,capi_rmat_intent,Py_None);
  if (capi_rmat_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `rmat' of slalib.sla_ecmat to C/Fortran array" );
  } else {
    rmat = (double *)(capi_rmat_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,rmat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_rmat_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_rmat_tmp == NULL) ... else of rmat*/
  /* End of cleaning variable rmat */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_ecmat ******************************/

/********************************** sla_ecor **********************************/
static char doc_f2py_rout_slalib_sla_ecor[] = "\
Function signature:\n\
  rv,tl = sla_ecor(rm,dm,iy,id,fd)\n\
Required arguments:\n"
"  rm : input float\n"
"  dm : input float\n"
"  iy : input int\n"
"  id : input int\n"
"  fd : input float\n"
"Return objects:\n"
"  rv : float\n"
"  tl : float";
/* extern void F_FUNC_US(sla_ecor,SLA_ECOR)(float*,float*,int*,int*,float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_ecor(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,int*,int*,float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float rm = 0;
  PyObject *rm_capi = Py_None;
  float dm = 0;
  PyObject *dm_capi = Py_None;
  int iy = 0;
  PyObject *iy_capi = Py_None;
  int id = 0;
  PyObject *id_capi = Py_None;
  float fd = 0;
  PyObject *fd_capi = Py_None;
  float rv = 0;
  float tl = 0;
  static char *capi_kwlist[] = {"rm","dm","iy","id","fd",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOO|:slalib.sla_ecor",\
    capi_kwlist,&rm_capi,&dm_capi,&iy_capi,&id_capi,&fd_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable iy */
    f2py_success = int_from_pyobj(&iy,iy_capi,"slalib.sla_ecor() 3rd argument (iy) can't be converted to int");
  if (f2py_success) {
  /* Processing variable rv */
  /* Processing variable dm */
    f2py_success = float_from_pyobj(&dm,dm_capi,"slalib.sla_ecor() 2nd argument (dm) can't be converted to float");
  if (f2py_success) {
  /* Processing variable fd */
    f2py_success = float_from_pyobj(&fd,fd_capi,"slalib.sla_ecor() 5th argument (fd) can't be converted to float");
  if (f2py_success) {
  /* Processing variable rm */
    f2py_success = float_from_pyobj(&rm,rm_capi,"slalib.sla_ecor() 1st argument (rm) can't be converted to float");
  if (f2py_success) {
  /* Processing variable tl */
  /* Processing variable id */
    f2py_success = int_from_pyobj(&id,id_capi,"slalib.sla_ecor() 4th argument (id) can't be converted to int");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&rm,&dm,&iy,&id,&fd,&rv,&tl);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ff",rv,tl);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of id*/
  /* End of cleaning variable id */
  /* End of cleaning variable tl */
  } /*if (f2py_success) of rm*/
  /* End of cleaning variable rm */
  } /*if (f2py_success) of fd*/
  /* End of cleaning variable fd */
  } /*if (f2py_success) of dm*/
  /* End of cleaning variable dm */
  /* End of cleaning variable rv */
  } /*if (f2py_success) of iy*/
  /* End of cleaning variable iy */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_ecor ******************************/

/********************************** sla_eg50 **********************************/
static char doc_f2py_rout_slalib_sla_eg50[] = "\
Function signature:\n\
  dl,db = sla_eg50(dr,dd)\n\
Required arguments:\n"
"  dr : input float\n"
"  dd : input float\n"
"Return objects:\n"
"  dl : float\n"
"  db : float";
/* extern void F_FUNC_US(sla_eg50,SLA_EG50)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_eg50(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double dr = 0;
  PyObject *dr_capi = Py_None;
  double dd = 0;
  PyObject *dd_capi = Py_None;
  double dl = 0;
  double db = 0;
  static char *capi_kwlist[] = {"dr","dd",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_eg50",\
    capi_kwlist,&dr_capi,&dd_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dr */
    f2py_success = double_from_pyobj(&dr,dr_capi,"slalib.sla_eg50() 1st argument (dr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dd */
    f2py_success = double_from_pyobj(&dd,dd_capi,"slalib.sla_eg50() 2nd argument (dd) can't be converted to double");
  if (f2py_success) {
  /* Processing variable db */
  /* Processing variable dl */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&dr,&dd,&dl,&db);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",dl,db);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dl */
  /* End of cleaning variable db */
  } /*if (f2py_success) of dd*/
  /* End of cleaning variable dd */
  } /*if (f2py_success) of dr*/
  /* End of cleaning variable dr */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_eg50 ******************************/

/********************************* sla_el2ue *********************************/
static char doc_f2py_rout_slalib_sla_el2ue[] = "\
Function signature:\n\
  u,jstat = sla_el2ue(date,jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm)\n\
Required arguments:\n"
"  date : input float\n"
"  jform : input int\n"
"  epoch : input float\n"
"  orbinc : input float\n"
"  anode : input float\n"
"  perih : input float\n"
"  aorq : input float\n"
"  e : input float\n"
"  aorl : input float\n"
"  dm : input float\n"
"Return objects:\n"
"  u : rank-1 array('d') with bounds (13)\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_el2ue,SLA_EL2UE)(double*,int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_el2ue(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  int jform = 0;
  PyObject *jform_capi = Py_None;
  double epoch = 0;
  PyObject *epoch_capi = Py_None;
  double orbinc = 0;
  PyObject *orbinc_capi = Py_None;
  double anode = 0;
  PyObject *anode_capi = Py_None;
  double perih = 0;
  PyObject *perih_capi = Py_None;
  double aorq = 0;
  PyObject *aorq_capi = Py_None;
  double e = 0;
  PyObject *e_capi = Py_None;
  double aorl = 0;
  PyObject *aorl_capi = Py_None;
  double dm = 0;
  PyObject *dm_capi = Py_None;
  double *u = NULL;
  npy_intp u_Dims[1] = {-1};
  const int u_Rank = 1;
  PyArrayObject *capi_u_tmp = NULL;
  int capi_u_intent = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"date","jform","epoch","orbinc","anode","perih","aorq","e","aorl","dm",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOOOO|:slalib.sla_el2ue",\
    capi_kwlist,&date_capi,&jform_capi,&epoch_capi,&orbinc_capi,&anode_capi,&perih_capi,&aorq_capi,&e_capi,&aorl_capi,&dm_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dm */
    f2py_success = double_from_pyobj(&dm,dm_capi,"slalib.sla_el2ue() 10th argument (dm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable e */
    f2py_success = double_from_pyobj(&e,e_capi,"slalib.sla_el2ue() 8th argument (e) can't be converted to double");
  if (f2py_success) {
  /* Processing variable perih */
    f2py_success = double_from_pyobj(&perih,perih_capi,"slalib.sla_el2ue() 6th argument (perih) can't be converted to double");
  if (f2py_success) {
  /* Processing variable aorl */
    f2py_success = double_from_pyobj(&aorl,aorl_capi,"slalib.sla_el2ue() 9th argument (aorl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable epoch */
    f2py_success = double_from_pyobj(&epoch,epoch_capi,"slalib.sla_el2ue() 3rd argument (epoch) can't be converted to double");
  if (f2py_success) {
  /* Processing variable orbinc */
    f2py_success = double_from_pyobj(&orbinc,orbinc_capi,"slalib.sla_el2ue() 4th argument (orbinc) can't be converted to double");
  if (f2py_success) {
  /* Processing variable anode */
    f2py_success = double_from_pyobj(&anode,anode_capi,"slalib.sla_el2ue() 5th argument (anode) can't be converted to double");
  if (f2py_success) {
  /* Processing variable aorq */
    f2py_success = double_from_pyobj(&aorq,aorq_capi,"slalib.sla_el2ue() 7th argument (aorq) can't be converted to double");
  if (f2py_success) {
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_el2ue() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable u */
  u_Dims[0]=13;
  capi_u_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_u_tmp = array_from_pyobj(PyArray_DOUBLE,u_Dims,u_Rank,capi_u_intent,Py_None);
  if (capi_u_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `u' of slalib.sla_el2ue to C/Fortran array" );
  } else {
    u = (double *)(capi_u_tmp->data);

  /* Processing variable jform */
    f2py_success = int_from_pyobj(&jform,jform_capi,"slalib.sla_el2ue() 2nd argument (jform) can't be converted to int");
  if (f2py_success) {
  /* Processing variable jstat */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,&jform,&epoch,&orbinc,&anode,&perih,&aorq,&e,&aorl,&dm,u,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Ni",capi_u_tmp,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable jstat */
  } /*if (f2py_success) of jform*/
  /* End of cleaning variable jform */
  }  /*if (capi_u_tmp == NULL) ... else of u*/
  /* End of cleaning variable u */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
  } /*if (f2py_success) of aorq*/
  /* End of cleaning variable aorq */
  } /*if (f2py_success) of anode*/
  /* End of cleaning variable anode */
  } /*if (f2py_success) of orbinc*/
  /* End of cleaning variable orbinc */
  } /*if (f2py_success) of epoch*/
  /* End of cleaning variable epoch */
  } /*if (f2py_success) of aorl*/
  /* End of cleaning variable aorl */
  } /*if (f2py_success) of perih*/
  /* End of cleaning variable perih */
  } /*if (f2py_success) of e*/
  /* End of cleaning variable e */
  } /*if (f2py_success) of dm*/
  /* End of cleaning variable dm */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_el2ue ******************************/

/********************************* sla_epb2d *********************************/
static char doc_f2py_rout_slalib_sla_epb2d[] = "\
Function signature:\n\
  sla_epb2d = sla_epb2d(epb)\n\
Required arguments:\n"
"  epb : input float\n"
"Return objects:\n"
"  sla_epb2d : float";
/* extern void F_WRAPPEDFUNC_US(sla_epb2d,SLA_EPB2D)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_epb2d(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_epb2d = 0;
  double epb = 0;
  PyObject *epb_capi = Py_None;
  static char *capi_kwlist[] = {"epb",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_epb2d",\
    capi_kwlist,&epb_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable sla_epb2d */
  /* Processing variable epb */
    f2py_success = double_from_pyobj(&epb,epb_capi,"slalib.sla_epb2d() 1st argument (epb) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_epb2d,&epb);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_epb2d);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of epb*/
  /* End of cleaning variable epb */
  /* End of cleaning variable sla_epb2d */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_epb2d ******************************/

/********************************** sla_epb **********************************/
static char doc_f2py_rout_slalib_sla_epb[] = "\
Function signature:\n\
  sla_epb = sla_epb(date)\n\
Required arguments:\n"
"  date : input float\n"
"Return objects:\n"
"  sla_epb : float";
/* extern void F_WRAPPEDFUNC_US(sla_epb,SLA_EPB)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_epb(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_epb = 0;
  double date = 0;
  PyObject *date_capi = Py_None;
  static char *capi_kwlist[] = {"date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_epb",\
    capi_kwlist,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_epb() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_epb */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_epb,&date);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_epb);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_epb */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_epb *******************************/

/********************************** sla_epco **********************************/
static char doc_f2py_rout_slalib_sla_epco[] = "\
Function signature:\n\
  sla_epco = sla_epco(k0,k,e)\n\
Required arguments:\n"
"  k0 : input string(len=-1)\n"
"  k : input string(len=-1)\n"
"  e : input float\n"
"Return objects:\n"
"  sla_epco : float";
/* extern void F_WRAPPEDFUNC_US(sla_epco,SLA_EPCO)(double*,string,string,double*,size_t,size_t); */
static PyObject *f2py_rout_slalib_sla_epco(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,string,string,double*,size_t,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_epco = 0;
  string k0 = NULL;
  int slen(k0);
  PyObject *k0_capi = Py_None;
  string k = NULL;
  int slen(k);
  PyObject *k_capi = Py_None;
  double e = 0;
  PyObject *e_capi = Py_None;
  static char *capi_kwlist[] = {"k0","k","e",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_epco",\
    capi_kwlist,&k0_capi,&k_capi,&e_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable e */
    f2py_success = double_from_pyobj(&e,e_capi,"slalib.sla_epco() 3rd argument (e) can't be converted to double");
  if (f2py_success) {
  /* Processing variable k */
  slen(k) = -1;
  f2py_success = string_from_pyobj(&k,&slen(k),"",k_capi,"string_from_pyobj failed in converting 2nd argument `k' of slalib.sla_epco to C string");
  if (f2py_success) {
  /* Processing variable k0 */
  slen(k0) = -1;
  f2py_success = string_from_pyobj(&k0,&slen(k0),"",k0_capi,"string_from_pyobj failed in converting 1st argument `k0' of slalib.sla_epco to C string");
  if (f2py_success) {
  /* Processing variable sla_epco */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_epco,k0,k,&e,slen(k0),slen(k));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_epco);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_epco */
    STRINGFREE(k0);
  }  /*if (f2py_success) of k0*/
  /* End of cleaning variable k0 */
    STRINGFREE(k);
  }  /*if (f2py_success) of k*/
  /* End of cleaning variable k */
  } /*if (f2py_success) of e*/
  /* End of cleaning variable e */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_epco ******************************/

/********************************* sla_epj2d *********************************/
static char doc_f2py_rout_slalib_sla_epj2d[] = "\
Function signature:\n\
  sla_epj2d = sla_epj2d(epj)\n\
Required arguments:\n"
"  epj : input float\n"
"Return objects:\n"
"  sla_epj2d : float";
/* extern void F_WRAPPEDFUNC_US(sla_epj2d,SLA_EPJ2D)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_epj2d(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_epj2d = 0;
  double epj = 0;
  PyObject *epj_capi = Py_None;
  static char *capi_kwlist[] = {"epj",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_epj2d",\
    capi_kwlist,&epj_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable sla_epj2d */
  /* Processing variable epj */
    f2py_success = double_from_pyobj(&epj,epj_capi,"slalib.sla_epj2d() 1st argument (epj) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_epj2d,&epj);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_epj2d);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of epj*/
  /* End of cleaning variable epj */
  /* End of cleaning variable sla_epj2d */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_epj2d ******************************/

/********************************** sla_epj **********************************/
static char doc_f2py_rout_slalib_sla_epj[] = "\
Function signature:\n\
  sla_epj = sla_epj(date)\n\
Required arguments:\n"
"  date : input float\n"
"Return objects:\n"
"  sla_epj : float";
/* extern void F_WRAPPEDFUNC_US(sla_epj,SLA_EPJ)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_epj(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_epj = 0;
  double date = 0;
  PyObject *date_capi = Py_None;
  static char *capi_kwlist[] = {"date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_epj",\
    capi_kwlist,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_epj() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_epj */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_epj,&date);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_epj);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_epj */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_epj *******************************/

/********************************** sla_epv **********************************/
static char doc_f2py_rout_slalib_sla_epv[] = "\
Function signature:\n\
  ph,vh,pb,vb = sla_epv(date)\n\
Required arguments:\n"
"  date : input float\n"
"Return objects:\n"
"  ph : rank-1 array('d') with bounds (3)\n"
"  vh : rank-1 array('d') with bounds (3)\n"
"  pb : rank-1 array('d') with bounds (3)\n"
"  vb : rank-1 array('d') with bounds (3)";
/* extern void F_FUNC_US(sla_epv,SLA_EPV)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_epv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double *ph = NULL;
  npy_intp ph_Dims[1] = {-1};
  const int ph_Rank = 1;
  PyArrayObject *capi_ph_tmp = NULL;
  int capi_ph_intent = 0;
  double *vh = NULL;
  npy_intp vh_Dims[1] = {-1};
  const int vh_Rank = 1;
  PyArrayObject *capi_vh_tmp = NULL;
  int capi_vh_intent = 0;
  double *pb = NULL;
  npy_intp pb_Dims[1] = {-1};
  const int pb_Rank = 1;
  PyArrayObject *capi_pb_tmp = NULL;
  int capi_pb_intent = 0;
  double *vb = NULL;
  npy_intp vb_Dims[1] = {-1};
  const int vb_Rank = 1;
  PyArrayObject *capi_vb_tmp = NULL;
  int capi_vb_intent = 0;
  static char *capi_kwlist[] = {"date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_epv",\
    capi_kwlist,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_epv() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable vh */
  vh_Dims[0]=3;
  capi_vh_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_vh_tmp = array_from_pyobj(PyArray_DOUBLE,vh_Dims,vh_Rank,capi_vh_intent,Py_None);
  if (capi_vh_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `vh' of slalib.sla_epv to C/Fortran array" );
  } else {
    vh = (double *)(capi_vh_tmp->data);

  /* Processing variable ph */
  ph_Dims[0]=3;
  capi_ph_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_ph_tmp = array_from_pyobj(PyArray_DOUBLE,ph_Dims,ph_Rank,capi_ph_intent,Py_None);
  if (capi_ph_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `ph' of slalib.sla_epv to C/Fortran array" );
  } else {
    ph = (double *)(capi_ph_tmp->data);

  /* Processing variable vb */
  vb_Dims[0]=3;
  capi_vb_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_vb_tmp = array_from_pyobj(PyArray_DOUBLE,vb_Dims,vb_Rank,capi_vb_intent,Py_None);
  if (capi_vb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `vb' of slalib.sla_epv to C/Fortran array" );
  } else {
    vb = (double *)(capi_vb_tmp->data);

  /* Processing variable pb */
  pb_Dims[0]=3;
  capi_pb_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_pb_tmp = array_from_pyobj(PyArray_DOUBLE,pb_Dims,pb_Rank,capi_pb_intent,Py_None);
  if (capi_pb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `pb' of slalib.sla_epv to C/Fortran array" );
  } else {
    pb = (double *)(capi_pb_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,ph,vh,pb,vb);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("NNNN",capi_ph_tmp,capi_vh_tmp,capi_pb_tmp,capi_vb_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_pb_tmp == NULL) ... else of pb*/
  /* End of cleaning variable pb */
  }  /*if (capi_vb_tmp == NULL) ... else of vb*/
  /* End of cleaning variable vb */
  }  /*if (capi_ph_tmp == NULL) ... else of ph*/
  /* End of cleaning variable ph */
  }  /*if (capi_vh_tmp == NULL) ... else of vh*/
  /* End of cleaning variable vh */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_epv *******************************/

/********************************* sla_eqecl *********************************/
static char doc_f2py_rout_slalib_sla_eqecl[] = "\
Function signature:\n\
  dl,db = sla_eqecl(dr,dd,date)\n\
Required arguments:\n"
"  dr : input float\n"
"  dd : input float\n"
"  date : input float\n"
"Return objects:\n"
"  dl : float\n"
"  db : float";
/* extern void F_FUNC_US(sla_eqecl,SLA_EQECL)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_eqecl(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double dr = 0;
  PyObject *dr_capi = Py_None;
  double dd = 0;
  PyObject *dd_capi = Py_None;
  double date = 0;
  PyObject *date_capi = Py_None;
  double dl = 0;
  double db = 0;
  static char *capi_kwlist[] = {"dr","dd","date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_eqecl",\
    capi_kwlist,&dr_capi,&dd_capi,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_eqecl() 3rd argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dr */
    f2py_success = double_from_pyobj(&dr,dr_capi,"slalib.sla_eqecl() 1st argument (dr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dd */
    f2py_success = double_from_pyobj(&dd,dd_capi,"slalib.sla_eqecl() 2nd argument (dd) can't be converted to double");
  if (f2py_success) {
  /* Processing variable db */
  /* Processing variable dl */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&dr,&dd,&date,&dl,&db);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",dl,db);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dl */
  /* End of cleaning variable db */
  } /*if (f2py_success) of dd*/
  /* End of cleaning variable dd */
  } /*if (f2py_success) of dr*/
  /* End of cleaning variable dr */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_eqecl ******************************/

/********************************* sla_eqeqx *********************************/
static char doc_f2py_rout_slalib_sla_eqeqx[] = "\
Function signature:\n\
  sla_eqeqx = sla_eqeqx(date)\n\
Required arguments:\n"
"  date : input float\n"
"Return objects:\n"
"  sla_eqeqx : float";
/* extern void F_WRAPPEDFUNC_US(sla_eqeqx,SLA_EQEQX)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_eqeqx(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_eqeqx = 0;
  double date = 0;
  PyObject *date_capi = Py_None;
  static char *capi_kwlist[] = {"date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_eqeqx",\
    capi_kwlist,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_eqeqx() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_eqeqx */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_eqeqx,&date);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_eqeqx);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_eqeqx */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_eqeqx ******************************/

/********************************* sla_eqgal *********************************/
static char doc_f2py_rout_slalib_sla_eqgal[] = "\
Function signature:\n\
  dl,db = sla_eqgal(dr,dd)\n\
Required arguments:\n"
"  dr : input float\n"
"  dd : input float\n"
"Return objects:\n"
"  dl : float\n"
"  db : float";
/* extern void F_FUNC_US(sla_eqgal,SLA_EQGAL)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_eqgal(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double dr = 0;
  PyObject *dr_capi = Py_None;
  double dd = 0;
  PyObject *dd_capi = Py_None;
  double dl = 0;
  double db = 0;
  static char *capi_kwlist[] = {"dr","dd",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_eqgal",\
    capi_kwlist,&dr_capi,&dd_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dr */
    f2py_success = double_from_pyobj(&dr,dr_capi,"slalib.sla_eqgal() 1st argument (dr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dd */
    f2py_success = double_from_pyobj(&dd,dd_capi,"slalib.sla_eqgal() 2nd argument (dd) can't be converted to double");
  if (f2py_success) {
  /* Processing variable db */
  /* Processing variable dl */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&dr,&dd,&dl,&db);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",dl,db);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dl */
  /* End of cleaning variable db */
  } /*if (f2py_success) of dd*/
  /* End of cleaning variable dd */
  } /*if (f2py_success) of dr*/
  /* End of cleaning variable dr */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_eqgal ******************************/

/********************************* sla_etrms *********************************/
static char doc_f2py_rout_slalib_sla_etrms[] = "\
Function signature:\n\
  ev = sla_etrms(ep)\n\
Required arguments:\n"
"  ep : input float\n"
"Return objects:\n"
"  ev : rank-1 array('d') with bounds (3)";
/* extern void F_FUNC_US(sla_etrms,SLA_ETRMS)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_etrms(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double ep = 0;
  PyObject *ep_capi = Py_None;
  double *ev = NULL;
  npy_intp ev_Dims[1] = {-1};
  const int ev_Rank = 1;
  PyArrayObject *capi_ev_tmp = NULL;
  int capi_ev_intent = 0;
  static char *capi_kwlist[] = {"ep",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_etrms",\
    capi_kwlist,&ep_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ev */
  ev_Dims[0]=3;
  capi_ev_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_ev_tmp = array_from_pyobj(PyArray_DOUBLE,ev_Dims,ev_Rank,capi_ev_intent,Py_None);
  if (capi_ev_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `ev' of slalib.sla_etrms to C/Fortran array" );
  } else {
    ev = (double *)(capi_ev_tmp->data);

  /* Processing variable ep */
    f2py_success = double_from_pyobj(&ep,ep_capi,"slalib.sla_etrms() 1st argument (ep) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ep,ev);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_ev_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of ep*/
  /* End of cleaning variable ep */
  }  /*if (capi_ev_tmp == NULL) ... else of ev*/
  /* End of cleaning variable ev */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_etrms ******************************/

/********************************* sla_euler *********************************/
static char doc_f2py_rout_slalib_sla_euler[] = "\
Function signature:\n\
  rmat = sla_euler(order,phi,theta,psi)\n\
Required arguments:\n"
"  order : input string(len=-1)\n"
"  phi : input float\n"
"  theta : input float\n"
"  psi : input float\n"
"Return objects:\n"
"  rmat : rank-2 array('f') with bounds (3,3)";
/* extern void F_FUNC_US(sla_euler,SLA_EULER)(string,float*,float*,float*,float*,size_t); */
static PyObject *f2py_rout_slalib_sla_euler(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,float*,float*,float*,float*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string order = NULL;
  int slen(order);
  PyObject *order_capi = Py_None;
  float phi = 0;
  PyObject *phi_capi = Py_None;
  float theta = 0;
  PyObject *theta_capi = Py_None;
  float psi = 0;
  PyObject *psi_capi = Py_None;
  float *rmat = NULL;
  npy_intp rmat_Dims[2] = {-1, -1};
  const int rmat_Rank = 2;
  PyArrayObject *capi_rmat_tmp = NULL;
  int capi_rmat_intent = 0;
  static char *capi_kwlist[] = {"order","phi","theta","psi",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_euler",\
    capi_kwlist,&order_capi,&phi_capi,&theta_capi,&psi_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rmat */
  rmat_Dims[0]=3,rmat_Dims[1]=3;
  capi_rmat_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_rmat_tmp = array_from_pyobj(PyArray_FLOAT,rmat_Dims,rmat_Rank,capi_rmat_intent,Py_None);
  if (capi_rmat_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `rmat' of slalib.sla_euler to C/Fortran array" );
  } else {
    rmat = (float *)(capi_rmat_tmp->data);

  /* Processing variable theta */
    f2py_success = float_from_pyobj(&theta,theta_capi,"slalib.sla_euler() 3rd argument (theta) can't be converted to float");
  if (f2py_success) {
  /* Processing variable phi */
    f2py_success = float_from_pyobj(&phi,phi_capi,"slalib.sla_euler() 2nd argument (phi) can't be converted to float");
  if (f2py_success) {
  /* Processing variable psi */
    f2py_success = float_from_pyobj(&psi,psi_capi,"slalib.sla_euler() 4th argument (psi) can't be converted to float");
  if (f2py_success) {
  /* Processing variable order */
  slen(order) = -1;
  f2py_success = string_from_pyobj(&order,&slen(order),"",order_capi,"string_from_pyobj failed in converting 1st argument `order' of slalib.sla_euler to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(order,&phi,&theta,&psi,rmat,slen(order));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_rmat_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(order);
  }  /*if (f2py_success) of order*/
  /* End of cleaning variable order */
  } /*if (f2py_success) of psi*/
  /* End of cleaning variable psi */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
  } /*if (f2py_success) of theta*/
  /* End of cleaning variable theta */
  }  /*if (capi_rmat_tmp == NULL) ... else of rmat*/
  /* End of cleaning variable rmat */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_euler ******************************/

/********************************** sla_evp **********************************/
static char doc_f2py_rout_slalib_sla_evp[] = "\
Function signature:\n\
  dvb,dpb,dvh,dph = sla_evp(date,deqx)\n\
Required arguments:\n"
"  date : input float\n"
"  deqx : input float\n"
"Return objects:\n"
"  dvb : rank-1 array('d') with bounds (3)\n"
"  dpb : rank-1 array('d') with bounds (3)\n"
"  dvh : rank-1 array('d') with bounds (3)\n"
"  dph : rank-1 array('d') with bounds (3)";
/* extern void F_FUNC_US(sla_evp,SLA_EVP)(double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_evp(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double deqx = 0;
  PyObject *deqx_capi = Py_None;
  double *dvb = NULL;
  npy_intp dvb_Dims[1] = {-1};
  const int dvb_Rank = 1;
  PyArrayObject *capi_dvb_tmp = NULL;
  int capi_dvb_intent = 0;
  double *dpb = NULL;
  npy_intp dpb_Dims[1] = {-1};
  const int dpb_Rank = 1;
  PyArrayObject *capi_dpb_tmp = NULL;
  int capi_dpb_intent = 0;
  double *dvh = NULL;
  npy_intp dvh_Dims[1] = {-1};
  const int dvh_Rank = 1;
  PyArrayObject *capi_dvh_tmp = NULL;
  int capi_dvh_intent = 0;
  double *dph = NULL;
  npy_intp dph_Dims[1] = {-1};
  const int dph_Rank = 1;
  PyArrayObject *capi_dph_tmp = NULL;
  int capi_dph_intent = 0;
  static char *capi_kwlist[] = {"date","deqx",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_evp",\
    capi_kwlist,&date_capi,&deqx_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable deqx */
    f2py_success = double_from_pyobj(&deqx,deqx_capi,"slalib.sla_evp() 2nd argument (deqx) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dvh */
  dvh_Dims[0]=3;
  capi_dvh_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_dvh_tmp = array_from_pyobj(PyArray_DOUBLE,dvh_Dims,dvh_Rank,capi_dvh_intent,Py_None);
  if (capi_dvh_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `dvh' of slalib.sla_evp to C/Fortran array" );
  } else {
    dvh = (double *)(capi_dvh_tmp->data);

  /* Processing variable dph */
  dph_Dims[0]=3;
  capi_dph_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_dph_tmp = array_from_pyobj(PyArray_DOUBLE,dph_Dims,dph_Rank,capi_dph_intent,Py_None);
  if (capi_dph_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `dph' of slalib.sla_evp to C/Fortran array" );
  } else {
    dph = (double *)(capi_dph_tmp->data);

  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_evp() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dpb */
  dpb_Dims[0]=3;
  capi_dpb_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_dpb_tmp = array_from_pyobj(PyArray_DOUBLE,dpb_Dims,dpb_Rank,capi_dpb_intent,Py_None);
  if (capi_dpb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `dpb' of slalib.sla_evp to C/Fortran array" );
  } else {
    dpb = (double *)(capi_dpb_tmp->data);

  /* Processing variable dvb */
  dvb_Dims[0]=3;
  capi_dvb_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_dvb_tmp = array_from_pyobj(PyArray_DOUBLE,dvb_Dims,dvb_Rank,capi_dvb_intent,Py_None);
  if (capi_dvb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `dvb' of slalib.sla_evp to C/Fortran array" );
  } else {
    dvb = (double *)(capi_dvb_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,&deqx,dvb,dpb,dvh,dph);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("NNNN",capi_dvb_tmp,capi_dpb_tmp,capi_dvh_tmp,capi_dph_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_dvb_tmp == NULL) ... else of dvb*/
  /* End of cleaning variable dvb */
  }  /*if (capi_dpb_tmp == NULL) ... else of dpb*/
  /* End of cleaning variable dpb */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
  }  /*if (capi_dph_tmp == NULL) ... else of dph*/
  /* End of cleaning variable dph */
  }  /*if (capi_dvh_tmp == NULL) ... else of dvh*/
  /* End of cleaning variable dvh */
  } /*if (f2py_success) of deqx*/
  /* End of cleaning variable deqx */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_evp *******************************/

/********************************* sla_fitxy *********************************/
static char doc_f2py_rout_slalib_sla_fitxy[] = "\
Function signature:\n\
  coeffs,j = sla_fitxy(itype,xye,xym,[np])\n\
Required arguments:\n"
"  itype : input int\n"
"  xye : input rank-2 array('d') with bounds (2,np)\n"
"  xym : input rank-2 array('d') with bounds (2,np)\n"
"Optional arguments:\n"
"  np := shape(xye,1) input int\n"
"Return objects:\n"
"  coeffs : rank-1 array('d') with bounds (6)\n"
"  j : int";
/* extern void F_FUNC_US(sla_fitxy,SLA_FITXY)(int*,int*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_fitxy(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int itype = 0;
  PyObject *itype_capi = Py_None;
  int np = 0;
  PyObject *np_capi = Py_None;
  double *xye = NULL;
  npy_intp xye_Dims[2] = {-1, -1};
  const int xye_Rank = 2;
  PyArrayObject *capi_xye_tmp = NULL;
  int capi_xye_intent = 0;
  PyObject *xye_capi = Py_None;
  double *xym = NULL;
  npy_intp xym_Dims[2] = {-1, -1};
  const int xym_Rank = 2;
  PyArrayObject *capi_xym_tmp = NULL;
  int capi_xym_intent = 0;
  PyObject *xym_capi = Py_None;
  double *coeffs = NULL;
  npy_intp coeffs_Dims[1] = {-1};
  const int coeffs_Rank = 1;
  PyArrayObject *capi_coeffs_tmp = NULL;
  int capi_coeffs_intent = 0;
  int j = 0;
  static char *capi_kwlist[] = {"itype","xye","xym","np",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|O:slalib.sla_fitxy",\
    capi_kwlist,&itype_capi,&xye_capi,&xym_capi,&np_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable itype */
    f2py_success = int_from_pyobj(&itype,itype_capi,"slalib.sla_fitxy() 1st argument (itype) can't be converted to int");
  if (f2py_success) {
  /* Processing variable xye */
  xye_Dims[0]=2;
  capi_xye_intent |= F2PY_INTENT_IN;
  capi_xye_tmp = array_from_pyobj(PyArray_DOUBLE,xye_Dims,xye_Rank,capi_xye_intent,xye_capi);
  if (capi_xye_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `xye' of slalib.sla_fitxy to C/Fortran array" );
  } else {
    xye = (double *)(capi_xye_tmp->data);

  /* Processing variable coeffs */
  coeffs_Dims[0]=6;
  capi_coeffs_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_coeffs_tmp = array_from_pyobj(PyArray_DOUBLE,coeffs_Dims,coeffs_Rank,capi_coeffs_intent,Py_None);
  if (capi_coeffs_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `coeffs' of slalib.sla_fitxy to C/Fortran array" );
  } else {
    coeffs = (double *)(capi_coeffs_tmp->data);

  /* Processing variable j */
  /* Processing variable np */
  if (np_capi == Py_None) np = shape(xye,1); else
    f2py_success = int_from_pyobj(&np,np_capi,"slalib.sla_fitxy() 1st keyword (np) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(shape(xye,1)==np,"shape(xye,1)==np","1st keyword np","sla_fitxy:np=%d",np) {
  /* Processing variable xym */
  xym_Dims[0]=2,xym_Dims[1]=np;
  capi_xym_intent |= F2PY_INTENT_IN;
  capi_xym_tmp = array_from_pyobj(PyArray_DOUBLE,xym_Dims,xym_Rank,capi_xym_intent,xym_capi);
  if (capi_xym_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `xym' of slalib.sla_fitxy to C/Fortran array" );
  } else {
    xym = (double *)(capi_xym_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&itype,&np,xye,xym,coeffs,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Ni",capi_coeffs_tmp,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_xym_tmp!=xym_capi) {
    Py_XDECREF(capi_xym_tmp); }
  }  /*if (capi_xym_tmp == NULL) ... else of xym*/
  /* End of cleaning variable xym */
  } /*CHECKSCALAR(shape(xye,1)==np)*/
  } /*if (f2py_success) of np*/
  /* End of cleaning variable np */
  /* End of cleaning variable j */
  }  /*if (capi_coeffs_tmp == NULL) ... else of coeffs*/
  /* End of cleaning variable coeffs */
  if((PyObject *)capi_xye_tmp!=xye_capi) {
    Py_XDECREF(capi_xye_tmp); }
  }  /*if (capi_xye_tmp == NULL) ... else of xye*/
  /* End of cleaning variable xye */
  } /*if (f2py_success) of itype*/
  /* End of cleaning variable itype */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_fitxy ******************************/

/********************************* sla_fk425 *********************************/
static char doc_f2py_rout_slalib_sla_fk425[] = "\
Function signature:\n\
  r2000,d2000,dr2000,dd2000,p2000,v2000 = sla_fk425(r1950,d1950,dr1950,dd1950,p1950,v1950)\n\
Required arguments:\n"
"  r1950 : input float\n"
"  d1950 : input float\n"
"  dr1950 : input float\n"
"  dd1950 : input float\n"
"  p1950 : input float\n"
"  v1950 : input float\n"
"Return objects:\n"
"  r2000 : float\n"
"  d2000 : float\n"
"  dr2000 : float\n"
"  dd2000 : float\n"
"  p2000 : float\n"
"  v2000 : float";
/* extern void F_FUNC_US(sla_fk425,SLA_FK425)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_fk425(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double r1950 = 0;
  PyObject *r1950_capi = Py_None;
  double d1950 = 0;
  PyObject *d1950_capi = Py_None;
  double dr1950 = 0;
  PyObject *dr1950_capi = Py_None;
  double dd1950 = 0;
  PyObject *dd1950_capi = Py_None;
  double p1950 = 0;
  PyObject *p1950_capi = Py_None;
  double v1950 = 0;
  PyObject *v1950_capi = Py_None;
  double r2000 = 0;
  double d2000 = 0;
  double dr2000 = 0;
  double dd2000 = 0;
  double p2000 = 0;
  double v2000 = 0;
  static char *capi_kwlist[] = {"r1950","d1950","dr1950","dd1950","p1950","v1950",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOO|:slalib.sla_fk425",\
    capi_kwlist,&r1950_capi,&d1950_capi,&dr1950_capi,&dd1950_capi,&p1950_capi,&v1950_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dr1950 */
    f2py_success = double_from_pyobj(&dr1950,dr1950_capi,"slalib.sla_fk425() 3rd argument (dr1950) can't be converted to double");
  if (f2py_success) {
  /* Processing variable p2000 */
  /* Processing variable p1950 */
    f2py_success = double_from_pyobj(&p1950,p1950_capi,"slalib.sla_fk425() 5th argument (p1950) can't be converted to double");
  if (f2py_success) {
  /* Processing variable v2000 */
  /* Processing variable r1950 */
    f2py_success = double_from_pyobj(&r1950,r1950_capi,"slalib.sla_fk425() 1st argument (r1950) can't be converted to double");
  if (f2py_success) {
  /* Processing variable d1950 */
    f2py_success = double_from_pyobj(&d1950,d1950_capi,"slalib.sla_fk425() 2nd argument (d1950) can't be converted to double");
  if (f2py_success) {
  /* Processing variable v1950 */
    f2py_success = double_from_pyobj(&v1950,v1950_capi,"slalib.sla_fk425() 6th argument (v1950) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dr2000 */
  /* Processing variable dd1950 */
    f2py_success = double_from_pyobj(&dd1950,dd1950_capi,"slalib.sla_fk425() 4th argument (dd1950) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dd2000 */
  /* Processing variable r2000 */
  /* Processing variable d2000 */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&r1950,&d1950,&dr1950,&dd1950,&p1950,&v1950,&r2000,&d2000,&dr2000,&dd2000,&p2000,&v2000);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dddddd",r2000,d2000,dr2000,dd2000,p2000,v2000);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable d2000 */
  /* End of cleaning variable r2000 */
  /* End of cleaning variable dd2000 */
  } /*if (f2py_success) of dd1950*/
  /* End of cleaning variable dd1950 */
  /* End of cleaning variable dr2000 */
  } /*if (f2py_success) of v1950*/
  /* End of cleaning variable v1950 */
  } /*if (f2py_success) of d1950*/
  /* End of cleaning variable d1950 */
  } /*if (f2py_success) of r1950*/
  /* End of cleaning variable r1950 */
  /* End of cleaning variable v2000 */
  } /*if (f2py_success) of p1950*/
  /* End of cleaning variable p1950 */
  /* End of cleaning variable p2000 */
  } /*if (f2py_success) of dr1950*/
  /* End of cleaning variable dr1950 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_fk425 ******************************/

/********************************* sla_fk45z *********************************/
static char doc_f2py_rout_slalib_sla_fk45z[] = "\
Function signature:\n\
  r2000,d2000 = sla_fk45z(r1950,d1950,bepoch)\n\
Required arguments:\n"
"  r1950 : input float\n"
"  d1950 : input float\n"
"  bepoch : input float\n"
"Return objects:\n"
"  r2000 : float\n"
"  d2000 : float";
/* extern void F_FUNC_US(sla_fk45z,SLA_FK45Z)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_fk45z(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double r1950 = 0;
  PyObject *r1950_capi = Py_None;
  double d1950 = 0;
  PyObject *d1950_capi = Py_None;
  double bepoch = 0;
  PyObject *bepoch_capi = Py_None;
  double r2000 = 0;
  double d2000 = 0;
  static char *capi_kwlist[] = {"r1950","d1950","bepoch",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_fk45z",\
    capi_kwlist,&r1950_capi,&d1950_capi,&bepoch_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable d1950 */
    f2py_success = double_from_pyobj(&d1950,d1950_capi,"slalib.sla_fk45z() 2nd argument (d1950) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r2000 */
  /* Processing variable bepoch */
    f2py_success = double_from_pyobj(&bepoch,bepoch_capi,"slalib.sla_fk45z() 3rd argument (bepoch) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r1950 */
    f2py_success = double_from_pyobj(&r1950,r1950_capi,"slalib.sla_fk45z() 1st argument (r1950) can't be converted to double");
  if (f2py_success) {
  /* Processing variable d2000 */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&r1950,&d1950,&bepoch,&r2000,&d2000);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",r2000,d2000);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable d2000 */
  } /*if (f2py_success) of r1950*/
  /* End of cleaning variable r1950 */
  } /*if (f2py_success) of bepoch*/
  /* End of cleaning variable bepoch */
  /* End of cleaning variable r2000 */
  } /*if (f2py_success) of d1950*/
  /* End of cleaning variable d1950 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_fk45z ******************************/

/********************************* sla_fk524 *********************************/
static char doc_f2py_rout_slalib_sla_fk524[] = "\
Function signature:\n\
  r1950,d1950,dr1950,dd1950,p1950,v1950 = sla_fk524(r2000,d2000,dr2000,dd2000,p2000,v2000)\n\
Required arguments:\n"
"  r2000 : input float\n"
"  d2000 : input float\n"
"  dr2000 : input float\n"
"  dd2000 : input float\n"
"  p2000 : input float\n"
"  v2000 : input float\n"
"Return objects:\n"
"  r1950 : float\n"
"  d1950 : float\n"
"  dr1950 : float\n"
"  dd1950 : float\n"
"  p1950 : float\n"
"  v1950 : float";
/* extern void F_FUNC_US(sla_fk524,SLA_FK524)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_fk524(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double r2000 = 0;
  PyObject *r2000_capi = Py_None;
  double d2000 = 0;
  PyObject *d2000_capi = Py_None;
  double dr2000 = 0;
  PyObject *dr2000_capi = Py_None;
  double dd2000 = 0;
  PyObject *dd2000_capi = Py_None;
  double p2000 = 0;
  PyObject *p2000_capi = Py_None;
  double v2000 = 0;
  PyObject *v2000_capi = Py_None;
  double r1950 = 0;
  double d1950 = 0;
  double dr1950 = 0;
  double dd1950 = 0;
  double p1950 = 0;
  double v1950 = 0;
  static char *capi_kwlist[] = {"r2000","d2000","dr2000","dd2000","p2000","v2000",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOO|:slalib.sla_fk524",\
    capi_kwlist,&r2000_capi,&d2000_capi,&dr2000_capi,&dd2000_capi,&p2000_capi,&v2000_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dr1950 */
  /* Processing variable p2000 */
    f2py_success = double_from_pyobj(&p2000,p2000_capi,"slalib.sla_fk524() 5th argument (p2000) can't be converted to double");
  if (f2py_success) {
  /* Processing variable p1950 */
  /* Processing variable v2000 */
    f2py_success = double_from_pyobj(&v2000,v2000_capi,"slalib.sla_fk524() 6th argument (v2000) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r1950 */
  /* Processing variable d1950 */
  /* Processing variable v1950 */
  /* Processing variable dr2000 */
    f2py_success = double_from_pyobj(&dr2000,dr2000_capi,"slalib.sla_fk524() 3rd argument (dr2000) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dd1950 */
  /* Processing variable dd2000 */
    f2py_success = double_from_pyobj(&dd2000,dd2000_capi,"slalib.sla_fk524() 4th argument (dd2000) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r2000 */
    f2py_success = double_from_pyobj(&r2000,r2000_capi,"slalib.sla_fk524() 1st argument (r2000) can't be converted to double");
  if (f2py_success) {
  /* Processing variable d2000 */
    f2py_success = double_from_pyobj(&d2000,d2000_capi,"slalib.sla_fk524() 2nd argument (d2000) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&r2000,&d2000,&dr2000,&dd2000,&p2000,&v2000,&r1950,&d1950,&dr1950,&dd1950,&p1950,&v1950);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dddddd",r1950,d1950,dr1950,dd1950,p1950,v1950);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of d2000*/
  /* End of cleaning variable d2000 */
  } /*if (f2py_success) of r2000*/
  /* End of cleaning variable r2000 */
  } /*if (f2py_success) of dd2000*/
  /* End of cleaning variable dd2000 */
  /* End of cleaning variable dd1950 */
  } /*if (f2py_success) of dr2000*/
  /* End of cleaning variable dr2000 */
  /* End of cleaning variable v1950 */
  /* End of cleaning variable d1950 */
  /* End of cleaning variable r1950 */
  } /*if (f2py_success) of v2000*/
  /* End of cleaning variable v2000 */
  /* End of cleaning variable p1950 */
  } /*if (f2py_success) of p2000*/
  /* End of cleaning variable p2000 */
  /* End of cleaning variable dr1950 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_fk524 ******************************/

/********************************* sla_fk52h *********************************/
static char doc_f2py_rout_slalib_sla_fk52h[] = "\
Function signature:\n\
  rh,dh,drh,ddh = sla_fk52h(r5,d5,dr5,dd5)\n\
Required arguments:\n"
"  r5 : input float\n"
"  d5 : input float\n"
"  dr5 : input float\n"
"  dd5 : input float\n"
"Return objects:\n"
"  rh : float\n"
"  dh : float\n"
"  drh : float\n"
"  ddh : float";
/* extern void F_FUNC_US(sla_fk52h,SLA_FK52H)(double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_fk52h(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double r5 = 0;
  PyObject *r5_capi = Py_None;
  double d5 = 0;
  PyObject *d5_capi = Py_None;
  double dr5 = 0;
  PyObject *dr5_capi = Py_None;
  double dd5 = 0;
  PyObject *dd5_capi = Py_None;
  double rh = 0;
  double dh = 0;
  double drh = 0;
  double ddh = 0;
  static char *capi_kwlist[] = {"r5","d5","dr5","dd5",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_fk52h",\
    capi_kwlist,&r5_capi,&d5_capi,&dr5_capi,&dd5_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable r5 */
    f2py_success = double_from_pyobj(&r5,r5_capi,"slalib.sla_fk52h() 1st argument (r5) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dh */
  /* Processing variable dr5 */
    f2py_success = double_from_pyobj(&dr5,dr5_capi,"slalib.sla_fk52h() 3rd argument (dr5) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dd5 */
    f2py_success = double_from_pyobj(&dd5,dd5_capi,"slalib.sla_fk52h() 4th argument (dd5) can't be converted to double");
  if (f2py_success) {
  /* Processing variable drh */
  /* Processing variable ddh */
  /* Processing variable d5 */
    f2py_success = double_from_pyobj(&d5,d5_capi,"slalib.sla_fk52h() 2nd argument (d5) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rh */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&r5,&d5,&dr5,&dd5,&rh,&dh,&drh,&ddh);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dddd",rh,dh,drh,ddh);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable rh */
  } /*if (f2py_success) of d5*/
  /* End of cleaning variable d5 */
  /* End of cleaning variable ddh */
  /* End of cleaning variable drh */
  } /*if (f2py_success) of dd5*/
  /* End of cleaning variable dd5 */
  } /*if (f2py_success) of dr5*/
  /* End of cleaning variable dr5 */
  /* End of cleaning variable dh */
  } /*if (f2py_success) of r5*/
  /* End of cleaning variable r5 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_fk52h ******************************/

/********************************* sla_fk54z *********************************/
static char doc_f2py_rout_slalib_sla_fk54z[] = "\
Function signature:\n\
  r1950,d1950,dr1950,dd1950 = sla_fk54z(r2000,d2000,bepoch)\n\
Required arguments:\n"
"  r2000 : input float\n"
"  d2000 : input float\n"
"  bepoch : input float\n"
"Return objects:\n"
"  r1950 : float\n"
"  d1950 : float\n"
"  dr1950 : float\n"
"  dd1950 : float";
/* extern void F_FUNC_US(sla_fk54z,SLA_FK54Z)(double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_fk54z(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double r2000 = 0;
  PyObject *r2000_capi = Py_None;
  double d2000 = 0;
  PyObject *d2000_capi = Py_None;
  double bepoch = 0;
  PyObject *bepoch_capi = Py_None;
  double r1950 = 0;
  double d1950 = 0;
  double dr1950 = 0;
  double dd1950 = 0;
  static char *capi_kwlist[] = {"r2000","d2000","bepoch",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_fk54z",\
    capi_kwlist,&r2000_capi,&d2000_capi,&bepoch_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dr1950 */
  /* Processing variable bepoch */
    f2py_success = double_from_pyobj(&bepoch,bepoch_capi,"slalib.sla_fk54z() 3rd argument (bepoch) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r1950 */
  /* Processing variable d1950 */
  /* Processing variable r2000 */
    f2py_success = double_from_pyobj(&r2000,r2000_capi,"slalib.sla_fk54z() 1st argument (r2000) can't be converted to double");
  if (f2py_success) {
  /* Processing variable d2000 */
    f2py_success = double_from_pyobj(&d2000,d2000_capi,"slalib.sla_fk54z() 2nd argument (d2000) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dd1950 */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&r2000,&d2000,&bepoch,&r1950,&d1950,&dr1950,&dd1950);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dddd",r1950,d1950,dr1950,dd1950);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dd1950 */
  } /*if (f2py_success) of d2000*/
  /* End of cleaning variable d2000 */
  } /*if (f2py_success) of r2000*/
  /* End of cleaning variable r2000 */
  /* End of cleaning variable d1950 */
  /* End of cleaning variable r1950 */
  } /*if (f2py_success) of bepoch*/
  /* End of cleaning variable bepoch */
  /* End of cleaning variable dr1950 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_fk54z ******************************/

/********************************* sla_fk5hz *********************************/
static char doc_f2py_rout_slalib_sla_fk5hz[] = "\
Function signature:\n\
  rh,dh = sla_fk5hz(r5,d5,epoch)\n\
Required arguments:\n"
"  r5 : input float\n"
"  d5 : input float\n"
"  epoch : input float\n"
"Return objects:\n"
"  rh : float\n"
"  dh : float";
/* extern void F_FUNC_US(sla_fk5hz,SLA_FK5HZ)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_fk5hz(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double r5 = 0;
  PyObject *r5_capi = Py_None;
  double d5 = 0;
  PyObject *d5_capi = Py_None;
  double epoch = 0;
  PyObject *epoch_capi = Py_None;
  double rh = 0;
  double dh = 0;
  static char *capi_kwlist[] = {"r5","d5","epoch",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_fk5hz",\
    capi_kwlist,&r5_capi,&d5_capi,&epoch_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable r5 */
    f2py_success = double_from_pyobj(&r5,r5_capi,"slalib.sla_fk5hz() 1st argument (r5) can't be converted to double");
  if (f2py_success) {
  /* Processing variable epoch */
    f2py_success = double_from_pyobj(&epoch,epoch_capi,"slalib.sla_fk5hz() 3rd argument (epoch) can't be converted to double");
  if (f2py_success) {
  /* Processing variable d5 */
    f2py_success = double_from_pyobj(&d5,d5_capi,"slalib.sla_fk5hz() 2nd argument (d5) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rh */
  /* Processing variable dh */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&r5,&d5,&epoch,&rh,&dh);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",rh,dh);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dh */
  /* End of cleaning variable rh */
  } /*if (f2py_success) of d5*/
  /* End of cleaning variable d5 */
  } /*if (f2py_success) of epoch*/
  /* End of cleaning variable epoch */
  } /*if (f2py_success) of r5*/
  /* End of cleaning variable r5 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_fk5hz ******************************/

/********************************* sla_flotin *********************************/
static char doc_f2py_rout_slalib_sla_flotin[] = "\
Function signature:\n\
  nstrt,reslt,jflag = sla_flotin(string_bn,nstrt)\n\
Required arguments:\n"
"  string_bn : input string(len=-1)\n"
"  nstrt : input int\n"
"Return objects:\n"
"  nstrt : int\n"
"  reslt : float\n"
"  jflag : int";
/* extern void F_FUNC_US(sla_flotin,SLA_FLOTIN)(string,int*,float*,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_flotin(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,int*,float*,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string string_bn = NULL;
  int slen(string_bn);
  PyObject *string_bn_capi = Py_None;
  int nstrt = 0;
  PyObject *nstrt_capi = Py_None;
  float reslt = 0;
  int jflag = 0;
  static char *capi_kwlist[] = {"string_bn","nstrt",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_flotin",\
    capi_kwlist,&string_bn_capi,&nstrt_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable string_bn */
  slen(string_bn) = -1;
  f2py_success = string_from_pyobj(&string_bn,&slen(string_bn),"",string_bn_capi,"string_from_pyobj failed in converting 1st argument `string_bn' of slalib.sla_flotin to C string");
  if (f2py_success) {
  /* Processing variable nstrt */
    f2py_success = int_from_pyobj(&nstrt,nstrt_capi,"slalib.sla_flotin() 2nd argument (nstrt) can't be converted to int");
  if (f2py_success) {
  /* Processing variable jflag */
  /* Processing variable reslt */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(string_bn,&nstrt,&reslt,&jflag,slen(string_bn));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ifi",nstrt,reslt,jflag);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable reslt */
  /* End of cleaning variable jflag */
  } /*if (f2py_success) of nstrt*/
  /* End of cleaning variable nstrt */
    STRINGFREE(string_bn);
  }  /*if (f2py_success) of string_bn*/
  /* End of cleaning variable string_bn */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_flotin *****************************/

/********************************* sla_galeq *********************************/
static char doc_f2py_rout_slalib_sla_galeq[] = "\
Function signature:\n\
  dr,dd = sla_galeq(dl,db)\n\
Required arguments:\n"
"  dl : input float\n"
"  db : input float\n"
"Return objects:\n"
"  dr : float\n"
"  dd : float";
/* extern void F_FUNC_US(sla_galeq,SLA_GALEQ)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_galeq(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double dl = 0;
  PyObject *dl_capi = Py_None;
  double db = 0;
  PyObject *db_capi = Py_None;
  double dr = 0;
  double dd = 0;
  static char *capi_kwlist[] = {"dl","db",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_galeq",\
    capi_kwlist,&dl_capi,&db_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable db */
    f2py_success = double_from_pyobj(&db,db_capi,"slalib.sla_galeq() 2nd argument (db) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dl */
    f2py_success = double_from_pyobj(&dl,dl_capi,"slalib.sla_galeq() 1st argument (dl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dr */
  /* Processing variable dd */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&dl,&db,&dr,&dd);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",dr,dd);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dd */
  /* End of cleaning variable dr */
  } /*if (f2py_success) of dl*/
  /* End of cleaning variable dl */
  } /*if (f2py_success) of db*/
  /* End of cleaning variable db */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_galeq ******************************/

/********************************* sla_galsup *********************************/
static char doc_f2py_rout_slalib_sla_galsup[] = "\
Function signature:\n\
  dsl,dsb = sla_galsup(dl,db)\n\
Required arguments:\n"
"  dl : input float\n"
"  db : input float\n"
"Return objects:\n"
"  dsl : float\n"
"  dsb : float";
/* extern void F_FUNC_US(sla_galsup,SLA_GALSUP)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_galsup(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double dl = 0;
  PyObject *dl_capi = Py_None;
  double db = 0;
  PyObject *db_capi = Py_None;
  double dsl = 0;
  double dsb = 0;
  static char *capi_kwlist[] = {"dl","db",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_galsup",\
    capi_kwlist,&dl_capi,&db_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable db */
    f2py_success = double_from_pyobj(&db,db_capi,"slalib.sla_galsup() 2nd argument (db) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dl */
    f2py_success = double_from_pyobj(&dl,dl_capi,"slalib.sla_galsup() 1st argument (dl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dsb */
  /* Processing variable dsl */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&dl,&db,&dsl,&dsb);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",dsl,dsb);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dsl */
  /* End of cleaning variable dsb */
  } /*if (f2py_success) of dl*/
  /* End of cleaning variable dl */
  } /*if (f2py_success) of db*/
  /* End of cleaning variable db */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_galsup *****************************/

/********************************** sla_ge50 **********************************/
static char doc_f2py_rout_slalib_sla_ge50[] = "\
Function signature:\n\
  dr,dd = sla_ge50(dl,db)\n\
Required arguments:\n"
"  dl : input float\n"
"  db : input float\n"
"Return objects:\n"
"  dr : float\n"
"  dd : float";
/* extern void F_FUNC_US(sla_ge50,SLA_GE50)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_ge50(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double dl = 0;
  PyObject *dl_capi = Py_None;
  double db = 0;
  PyObject *db_capi = Py_None;
  double dr = 0;
  double dd = 0;
  static char *capi_kwlist[] = {"dl","db",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_ge50",\
    capi_kwlist,&dl_capi,&db_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable db */
    f2py_success = double_from_pyobj(&db,db_capi,"slalib.sla_ge50() 2nd argument (db) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dl */
    f2py_success = double_from_pyobj(&dl,dl_capi,"slalib.sla_ge50() 1st argument (dl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dr */
  /* Processing variable dd */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&dl,&db,&dr,&dd);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",dr,dd);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dd */
  /* End of cleaning variable dr */
  } /*if (f2py_success) of dl*/
  /* End of cleaning variable dl */
  } /*if (f2py_success) of db*/
  /* End of cleaning variable db */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_ge50 ******************************/

/********************************** sla_geoc **********************************/
static char doc_f2py_rout_slalib_sla_geoc[] = "\
Function signature:\n\
  r,z = sla_geoc(p,h)\n\
Required arguments:\n"
"  p : input float\n"
"  h : input float\n"
"Return objects:\n"
"  r : float\n"
"  z : float";
/* extern void F_FUNC_US(sla_geoc,SLA_GEOC)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_geoc(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double p = 0;
  PyObject *p_capi = Py_None;
  double h = 0;
  PyObject *h_capi = Py_None;
  double r = 0;
  double z = 0;
  static char *capi_kwlist[] = {"p","h",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_geoc",\
    capi_kwlist,&p_capi,&h_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable p */
    f2py_success = double_from_pyobj(&p,p_capi,"slalib.sla_geoc() 1st argument (p) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r */
  /* Processing variable z */
  /* Processing variable h */
    f2py_success = double_from_pyobj(&h,h_capi,"slalib.sla_geoc() 2nd argument (h) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&p,&h,&r,&z);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",r,z);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of h*/
  /* End of cleaning variable h */
  /* End of cleaning variable z */
  /* End of cleaning variable r */
  } /*if (f2py_success) of p*/
  /* End of cleaning variable p */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_geoc ******************************/

/********************************* sla_gmsta *********************************/
static char doc_f2py_rout_slalib_sla_gmsta[] = "\
Function signature:\n\
  sla_gmsta = sla_gmsta(date,ut)\n\
Required arguments:\n"
"  date : input float\n"
"  ut : input float\n"
"Return objects:\n"
"  sla_gmsta : float";
/* extern void F_WRAPPEDFUNC_US(sla_gmsta,SLA_GMSTA)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_gmsta(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_gmsta = 0;
  double date = 0;
  PyObject *date_capi = Py_None;
  double ut = 0;
  PyObject *ut_capi = Py_None;
  static char *capi_kwlist[] = {"date","ut",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_gmsta",\
    capi_kwlist,&date_capi,&ut_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_gmsta() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ut */
    f2py_success = double_from_pyobj(&ut,ut_capi,"slalib.sla_gmsta() 2nd argument (ut) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_gmsta */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_gmsta,&date,&ut);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_gmsta);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_gmsta */
  } /*if (f2py_success) of ut*/
  /* End of cleaning variable ut */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_gmsta ******************************/

/********************************** sla_gmst **********************************/
static char doc_f2py_rout_slalib_sla_gmst[] = "\
Function signature:\n\
  sla_gmst = sla_gmst(ut1)\n\
Required arguments:\n"
"  ut1 : input float\n"
"Return objects:\n"
"  sla_gmst : float";
/* extern void F_WRAPPEDFUNC_US(sla_gmst,SLA_GMST)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_gmst(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_gmst = 0;
  double ut1 = 0;
  PyObject *ut1_capi = Py_None;
  static char *capi_kwlist[] = {"ut1",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_gmst",\
    capi_kwlist,&ut1_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable sla_gmst */
  /* Processing variable ut1 */
    f2py_success = double_from_pyobj(&ut1,ut1_capi,"slalib.sla_gmst() 1st argument (ut1) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_gmst,&ut1);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_gmst);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of ut1*/
  /* End of cleaning variable ut1 */
  /* End of cleaning variable sla_gmst */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_gmst ******************************/

/********************************** sla_h2e **********************************/
static char doc_f2py_rout_slalib_sla_h2e[] = "\
Function signature:\n\
  ha,dec = sla_h2e(az,el,phi)\n\
Required arguments:\n"
"  az : input float\n"
"  el : input float\n"
"  phi : input float\n"
"Return objects:\n"
"  ha : float\n"
"  dec : float";
/* extern void F_FUNC_US(sla_h2e,SLA_H2E)(float*,float*,float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_h2e(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float az = 0;
  PyObject *az_capi = Py_None;
  float el = 0;
  PyObject *el_capi = Py_None;
  float phi = 0;
  PyObject *phi_capi = Py_None;
  float ha = 0;
  float dec = 0;
  static char *capi_kwlist[] = {"az","el","phi",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_h2e",\
    capi_kwlist,&az_capi,&el_capi,&phi_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dec */
  /* Processing variable el */
    f2py_success = float_from_pyobj(&el,el_capi,"slalib.sla_h2e() 2nd argument (el) can't be converted to float");
  if (f2py_success) {
  /* Processing variable phi */
    f2py_success = float_from_pyobj(&phi,phi_capi,"slalib.sla_h2e() 3rd argument (phi) can't be converted to float");
  if (f2py_success) {
  /* Processing variable ha */
  /* Processing variable az */
    f2py_success = float_from_pyobj(&az,az_capi,"slalib.sla_h2e() 1st argument (az) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&az,&el,&phi,&ha,&dec);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ff",ha,dec);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of az*/
  /* End of cleaning variable az */
  /* End of cleaning variable ha */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
  } /*if (f2py_success) of el*/
  /* End of cleaning variable el */
  /* End of cleaning variable dec */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_h2e *******************************/

/********************************* sla_h2fk5 *********************************/
static char doc_f2py_rout_slalib_sla_h2fk5[] = "\
Function signature:\n\
  r5,d5,dr5,dd5 = sla_h2fk5(rh,dh,drh,ddh)\n\
Required arguments:\n"
"  rh : input float\n"
"  dh : input float\n"
"  drh : input float\n"
"  ddh : input float\n"
"Return objects:\n"
"  r5 : float\n"
"  d5 : float\n"
"  dr5 : float\n"
"  dd5 : float";
/* extern void F_FUNC_US(sla_h2fk5,SLA_H2FK5)(double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_h2fk5(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double rh = 0;
  PyObject *rh_capi = Py_None;
  double dh = 0;
  PyObject *dh_capi = Py_None;
  double drh = 0;
  PyObject *drh_capi = Py_None;
  double ddh = 0;
  PyObject *ddh_capi = Py_None;
  double r5 = 0;
  double d5 = 0;
  double dr5 = 0;
  double dd5 = 0;
  static char *capi_kwlist[] = {"rh","dh","drh","ddh",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_h2fk5",\
    capi_kwlist,&rh_capi,&dh_capi,&drh_capi,&ddh_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable r5 */
  /* Processing variable dh */
    f2py_success = double_from_pyobj(&dh,dh_capi,"slalib.sla_h2fk5() 2nd argument (dh) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dr5 */
  /* Processing variable dd5 */
  /* Processing variable drh */
    f2py_success = double_from_pyobj(&drh,drh_capi,"slalib.sla_h2fk5() 3rd argument (drh) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ddh */
    f2py_success = double_from_pyobj(&ddh,ddh_capi,"slalib.sla_h2fk5() 4th argument (ddh) can't be converted to double");
  if (f2py_success) {
  /* Processing variable d5 */
  /* Processing variable rh */
    f2py_success = double_from_pyobj(&rh,rh_capi,"slalib.sla_h2fk5() 1st argument (rh) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&rh,&dh,&drh,&ddh,&r5,&d5,&dr5,&dd5);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dddd",r5,d5,dr5,dd5);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of rh*/
  /* End of cleaning variable rh */
  /* End of cleaning variable d5 */
  } /*if (f2py_success) of ddh*/
  /* End of cleaning variable ddh */
  } /*if (f2py_success) of drh*/
  /* End of cleaning variable drh */
  /* End of cleaning variable dd5 */
  /* End of cleaning variable dr5 */
  } /*if (f2py_success) of dh*/
  /* End of cleaning variable dh */
  /* End of cleaning variable r5 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_h2fk5 ******************************/

/********************************* sla_hfk5z *********************************/
static char doc_f2py_rout_slalib_sla_hfk5z[] = "\
Function signature:\n\
  r5,d5,dr5,dd5 = sla_hfk5z(rh,dh,epoch)\n\
Required arguments:\n"
"  rh : input float\n"
"  dh : input float\n"
"  epoch : input float\n"
"Return objects:\n"
"  r5 : float\n"
"  d5 : float\n"
"  dr5 : float\n"
"  dd5 : float";
/* extern void F_FUNC_US(sla_hfk5z,SLA_HFK5Z)(double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_hfk5z(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double rh = 0;
  PyObject *rh_capi = Py_None;
  double dh = 0;
  PyObject *dh_capi = Py_None;
  double epoch = 0;
  PyObject *epoch_capi = Py_None;
  double r5 = 0;
  double d5 = 0;
  double dr5 = 0;
  double dd5 = 0;
  static char *capi_kwlist[] = {"rh","dh","epoch",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_hfk5z",\
    capi_kwlist,&rh_capi,&dh_capi,&epoch_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable r5 */
  /* Processing variable epoch */
    f2py_success = double_from_pyobj(&epoch,epoch_capi,"slalib.sla_hfk5z() 3rd argument (epoch) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dh */
    f2py_success = double_from_pyobj(&dh,dh_capi,"slalib.sla_hfk5z() 2nd argument (dh) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rh */
    f2py_success = double_from_pyobj(&rh,rh_capi,"slalib.sla_hfk5z() 1st argument (rh) can't be converted to double");
  if (f2py_success) {
  /* Processing variable d5 */
  /* Processing variable dr5 */
  /* Processing variable dd5 */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&rh,&dh,&epoch,&r5,&d5,&dr5,&dd5);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dddd",r5,d5,dr5,dd5);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dd5 */
  /* End of cleaning variable dr5 */
  /* End of cleaning variable d5 */
  } /*if (f2py_success) of rh*/
  /* End of cleaning variable rh */
  } /*if (f2py_success) of dh*/
  /* End of cleaning variable dh */
  } /*if (f2py_success) of epoch*/
  /* End of cleaning variable epoch */
  /* End of cleaning variable r5 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_hfk5z ******************************/

/********************************* sla__idchf *********************************/
static char doc_f2py_rout_slalib_sla__idchf[] = "\
Function signature:\n\
  nptr,nvec,ndigit,digit = sla__idchf(string_bn,nptr)\n\
Required arguments:\n"
"  string_bn : input string(len=-1)\n"
"  nptr : input int\n"
"Return objects:\n"
"  nptr : int\n"
"  nvec : int\n"
"  ndigit : int\n"
"  digit : float";
/* extern void F_FUNC_US(sla__idchf,SLA__IDCHF)(string,int*,int*,int*,double*,size_t); */
static PyObject *f2py_rout_slalib_sla__idchf(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,int*,int*,int*,double*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string string_bn = NULL;
  int slen(string_bn);
  PyObject *string_bn_capi = Py_None;
  int nptr = 0;
  PyObject *nptr_capi = Py_None;
  int nvec = 0;
  int ndigit = 0;
  double digit = 0;
  static char *capi_kwlist[] = {"string_bn","nptr",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla__idchf",\
    capi_kwlist,&string_bn_capi,&nptr_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable nptr */
    f2py_success = int_from_pyobj(&nptr,nptr_capi,"slalib.sla__idchf() 2nd argument (nptr) can't be converted to int");
  if (f2py_success) {
  /* Processing variable digit */
  /* Processing variable ndigit */
  /* Processing variable nvec */
  /* Processing variable string_bn */
  slen(string_bn) = -1;
  f2py_success = string_from_pyobj(&string_bn,&slen(string_bn),"",string_bn_capi,"string_from_pyobj failed in converting 1st argument `string_bn' of slalib.sla__idchf to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(string_bn,&nptr,&nvec,&ndigit,&digit,slen(string_bn));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("iiid",nptr,nvec,ndigit,digit);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(string_bn);
  }  /*if (f2py_success) of string_bn*/
  /* End of cleaning variable string_bn */
  /* End of cleaning variable nvec */
  /* End of cleaning variable ndigit */
  /* End of cleaning variable digit */
  } /*if (f2py_success) of nptr*/
  /* End of cleaning variable nptr */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla__idchf *****************************/

/********************************* sla__idchi *********************************/
static char doc_f2py_rout_slalib_sla__idchi[] = "\
Function signature:\n\
  nptr,nvec,digit = sla__idchi(string_bn,nptr)\n\
Required arguments:\n"
"  string_bn : input string(len=-1)\n"
"  nptr : input int\n"
"Return objects:\n"
"  nptr : int\n"
"  nvec : int\n"
"  digit : float";
/* extern void F_FUNC_US(sla__idchi,SLA__IDCHI)(string,int*,int*,double*,size_t); */
static PyObject *f2py_rout_slalib_sla__idchi(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,int*,int*,double*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string string_bn = NULL;
  int slen(string_bn);
  PyObject *string_bn_capi = Py_None;
  int nptr = 0;
  PyObject *nptr_capi = Py_None;
  int nvec = 0;
  double digit = 0;
  static char *capi_kwlist[] = {"string_bn","nptr",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla__idchi",\
    capi_kwlist,&string_bn_capi,&nptr_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable nptr */
    f2py_success = int_from_pyobj(&nptr,nptr_capi,"slalib.sla__idchi() 2nd argument (nptr) can't be converted to int");
  if (f2py_success) {
  /* Processing variable digit */
  /* Processing variable nvec */
  /* Processing variable string_bn */
  slen(string_bn) = -1;
  f2py_success = string_from_pyobj(&string_bn,&slen(string_bn),"",string_bn_capi,"string_from_pyobj failed in converting 1st argument `string_bn' of slalib.sla__idchi to C string");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(string_bn,&nptr,&nvec,&digit,slen(string_bn));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("iid",nptr,nvec,digit);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
    STRINGFREE(string_bn);
  }  /*if (f2py_success) of string_bn*/
  /* End of cleaning variable string_bn */
  /* End of cleaning variable nvec */
  /* End of cleaning variable digit */
  } /*if (f2py_success) of nptr*/
  /* End of cleaning variable nptr */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla__idchi *****************************/

/********************************** sla_imxv **********************************/
static char doc_f2py_rout_slalib_sla_imxv[] = "\
Function signature:\n\
  vb = sla_imxv(rm,va)\n\
Required arguments:\n"
"  rm : input rank-2 array('f') with bounds (3,3)\n"
"  va : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  vb : rank-1 array('f') with bounds (3)";
/* extern void F_FUNC_US(sla_imxv,SLA_IMXV)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_imxv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float *rm = NULL;
  npy_intp rm_Dims[2] = {-1, -1};
  const int rm_Rank = 2;
  PyArrayObject *capi_rm_tmp = NULL;
  int capi_rm_intent = 0;
  PyObject *rm_capi = Py_None;
  float *va = NULL;
  npy_intp va_Dims[1] = {-1};
  const int va_Rank = 1;
  PyArrayObject *capi_va_tmp = NULL;
  int capi_va_intent = 0;
  PyObject *va_capi = Py_None;
  float *vb = NULL;
  npy_intp vb_Dims[1] = {-1};
  const int vb_Rank = 1;
  PyArrayObject *capi_vb_tmp = NULL;
  int capi_vb_intent = 0;
  static char *capi_kwlist[] = {"rm","va",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_imxv",\
    capi_kwlist,&rm_capi,&va_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rm */
  rm_Dims[0]=3,rm_Dims[1]=3;
  capi_rm_intent |= F2PY_INTENT_IN;
  capi_rm_tmp = array_from_pyobj(PyArray_FLOAT,rm_Dims,rm_Rank,capi_rm_intent,rm_capi);
  if (capi_rm_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `rm' of slalib.sla_imxv to C/Fortran array" );
  } else {
    rm = (float *)(capi_rm_tmp->data);

  /* Processing variable vb */
  vb_Dims[0]=3;
  capi_vb_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_vb_tmp = array_from_pyobj(PyArray_FLOAT,vb_Dims,vb_Rank,capi_vb_intent,Py_None);
  if (capi_vb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `vb' of slalib.sla_imxv to C/Fortran array" );
  } else {
    vb = (float *)(capi_vb_tmp->data);

  /* Processing variable va */
  va_Dims[0]=3;
  capi_va_intent |= F2PY_INTENT_IN;
  capi_va_tmp = array_from_pyobj(PyArray_FLOAT,va_Dims,va_Rank,capi_va_intent,va_capi);
  if (capi_va_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `va' of slalib.sla_imxv to C/Fortran array" );
  } else {
    va = (float *)(capi_va_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(rm,va,vb);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_vb_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_va_tmp!=va_capi) {
    Py_XDECREF(capi_va_tmp); }
  }  /*if (capi_va_tmp == NULL) ... else of va*/
  /* End of cleaning variable va */
  }  /*if (capi_vb_tmp == NULL) ... else of vb*/
  /* End of cleaning variable vb */
  if((PyObject *)capi_rm_tmp!=rm_capi) {
    Py_XDECREF(capi_rm_tmp); }
  }  /*if (capi_rm_tmp == NULL) ... else of rm*/
  /* End of cleaning variable rm */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_imxv ******************************/

/********************************* sla_intin *********************************/
static char doc_f2py_rout_slalib_sla_intin[] = "\
Function signature:\n\
  nstrt,ireslt,jflag = sla_intin(string_bn,nstrt)\n\
Required arguments:\n"
"  string_bn : input string(len=-1)\n"
"  nstrt : input int\n"
"Return objects:\n"
"  nstrt : int\n"
"  ireslt : int\n"
"  jflag : int";
/* extern void F_FUNC_US(sla_intin,SLA_INTIN)(string,int*,int*,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_intin(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,int*,int*,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string string_bn = NULL;
  int slen(string_bn);
  PyObject *string_bn_capi = Py_None;
  int nstrt = 0;
  PyObject *nstrt_capi = Py_None;
  int ireslt = 0;
  int jflag = 0;
  static char *capi_kwlist[] = {"string_bn","nstrt",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_intin",\
    capi_kwlist,&string_bn_capi,&nstrt_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable string_bn */
  slen(string_bn) = -1;
  f2py_success = string_from_pyobj(&string_bn,&slen(string_bn),"",string_bn_capi,"string_from_pyobj failed in converting 1st argument `string_bn' of slalib.sla_intin to C string");
  if (f2py_success) {
  /* Processing variable nstrt */
    f2py_success = int_from_pyobj(&nstrt,nstrt_capi,"slalib.sla_intin() 2nd argument (nstrt) can't be converted to int");
  if (f2py_success) {
  /* Processing variable jflag */
  /* Processing variable ireslt */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(string_bn,&nstrt,&ireslt,&jflag,slen(string_bn));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("iii",nstrt,ireslt,jflag);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable ireslt */
  /* End of cleaning variable jflag */
  } /*if (f2py_success) of nstrt*/
  /* End of cleaning variable nstrt */
    STRINGFREE(string_bn);
  }  /*if (f2py_success) of string_bn*/
  /* End of cleaning variable string_bn */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_intin ******************************/

/********************************** sla_invf **********************************/
static char doc_f2py_rout_slalib_sla_invf[] = "\
Function signature:\n\
  bkwds,j = sla_invf(fwds)\n\
Required arguments:\n"
"  fwds : input rank-1 array('d') with bounds (6)\n"
"Return objects:\n"
"  bkwds : rank-1 array('d') with bounds (6)\n"
"  j : int";
/* extern void F_FUNC_US(sla_invf,SLA_INVF)(double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_invf(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *fwds = NULL;
  npy_intp fwds_Dims[1] = {-1};
  const int fwds_Rank = 1;
  PyArrayObject *capi_fwds_tmp = NULL;
  int capi_fwds_intent = 0;
  PyObject *fwds_capi = Py_None;
  double *bkwds = NULL;
  npy_intp bkwds_Dims[1] = {-1};
  const int bkwds_Rank = 1;
  PyArrayObject *capi_bkwds_tmp = NULL;
  int capi_bkwds_intent = 0;
  int j = 0;
  static char *capi_kwlist[] = {"fwds",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_invf",\
    capi_kwlist,&fwds_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable bkwds */
  bkwds_Dims[0]=6;
  capi_bkwds_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_bkwds_tmp = array_from_pyobj(PyArray_DOUBLE,bkwds_Dims,bkwds_Rank,capi_bkwds_intent,Py_None);
  if (capi_bkwds_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `bkwds' of slalib.sla_invf to C/Fortran array" );
  } else {
    bkwds = (double *)(capi_bkwds_tmp->data);

  /* Processing variable j */
  /* Processing variable fwds */
  fwds_Dims[0]=6;
  capi_fwds_intent |= F2PY_INTENT_IN;
  capi_fwds_tmp = array_from_pyobj(PyArray_DOUBLE,fwds_Dims,fwds_Rank,capi_fwds_intent,fwds_capi);
  if (capi_fwds_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `fwds' of slalib.sla_invf to C/Fortran array" );
  } else {
    fwds = (double *)(capi_fwds_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(fwds,bkwds,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Ni",capi_bkwds_tmp,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_fwds_tmp!=fwds_capi) {
    Py_XDECREF(capi_fwds_tmp); }
  }  /*if (capi_fwds_tmp == NULL) ... else of fwds*/
  /* End of cleaning variable fwds */
  /* End of cleaning variable j */
  }  /*if (capi_bkwds_tmp == NULL) ... else of bkwds*/
  /* End of cleaning variable bkwds */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_invf ******************************/

/********************************** sla_kbj **********************************/
static char doc_f2py_rout_slalib_sla_kbj[] = "\
Function signature:\n\
  k,j = sla_kbj(jb,e)\n\
Required arguments:\n"
"  jb : input int\n"
"  e : input float\n"
"Return objects:\n"
"  k : string(len=1)\n"
"  j : int";
/* extern void F_FUNC_US(sla_kbj,SLA_KBJ)(int*,double*,string,int*,size_t); */
static PyObject *f2py_rout_slalib_sla_kbj(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,double*,string,int*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int jb = 0;
  PyObject *jb_capi = Py_None;
  double e = 0;
  PyObject *e_capi = Py_None;
  string k = NULL;
  int slen(k);
  PyObject *k_capi = Py_None;
  int j = 0;
  static char *capi_kwlist[] = {"jb","e",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_kbj",\
    capi_kwlist,&jb_capi,&e_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable k */
  slen(k) = 1;
  f2py_success = string_from_pyobj(&k,&slen(k),"",k_capi,"string_from_pyobj failed in converting hidden `k' of slalib.sla_kbj to C string");
  if (f2py_success) {
  /* Processing variable j */
  /* Processing variable e */
    f2py_success = double_from_pyobj(&e,e_capi,"slalib.sla_kbj() 2nd argument (e) can't be converted to double");
  if (f2py_success) {
  /* Processing variable jb */
    f2py_success = int_from_pyobj(&jb,jb_capi,"slalib.sla_kbj() 1st argument (jb) can't be converted to int");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&jb,&e,k,&j,slen(k));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("zi",k,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of jb*/
  /* End of cleaning variable jb */
  } /*if (f2py_success) of e*/
  /* End of cleaning variable e */
  /* End of cleaning variable j */
    STRINGFREE(k);
  }  /*if (f2py_success) of k*/
  /* End of cleaning variable k */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_kbj *******************************/

/********************************** sla_m2av **********************************/
static char doc_f2py_rout_slalib_sla_m2av[] = "\
Function signature:\n\
  axvec = sla_m2av(rmat)\n\
Required arguments:\n"
"  rmat : input rank-2 array('f') with bounds (3,3)\n"
"Return objects:\n"
"  axvec : rank-1 array('f') with bounds (3)";
/* extern void F_FUNC_US(sla_m2av,SLA_M2AV)(float*,float*); */
static PyObject *f2py_rout_slalib_sla_m2av(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float *rmat = NULL;
  npy_intp rmat_Dims[2] = {-1, -1};
  const int rmat_Rank = 2;
  PyArrayObject *capi_rmat_tmp = NULL;
  int capi_rmat_intent = 0;
  PyObject *rmat_capi = Py_None;
  float *axvec = NULL;
  npy_intp axvec_Dims[1] = {-1};
  const int axvec_Rank = 1;
  PyArrayObject *capi_axvec_tmp = NULL;
  int capi_axvec_intent = 0;
  static char *capi_kwlist[] = {"rmat",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_m2av",\
    capi_kwlist,&rmat_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rmat */
  rmat_Dims[0]=3,rmat_Dims[1]=3;
  capi_rmat_intent |= F2PY_INTENT_IN;
  capi_rmat_tmp = array_from_pyobj(PyArray_FLOAT,rmat_Dims,rmat_Rank,capi_rmat_intent,rmat_capi);
  if (capi_rmat_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `rmat' of slalib.sla_m2av to C/Fortran array" );
  } else {
    rmat = (float *)(capi_rmat_tmp->data);

  /* Processing variable axvec */
  axvec_Dims[0]=3;
  capi_axvec_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_axvec_tmp = array_from_pyobj(PyArray_FLOAT,axvec_Dims,axvec_Rank,capi_axvec_intent,Py_None);
  if (capi_axvec_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `axvec' of slalib.sla_m2av to C/Fortran array" );
  } else {
    axvec = (float *)(capi_axvec_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(rmat,axvec);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_axvec_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_axvec_tmp == NULL) ... else of axvec*/
  /* End of cleaning variable axvec */
  if((PyObject *)capi_rmat_tmp!=rmat_capi) {
    Py_XDECREF(capi_rmat_tmp); }
  }  /*if (capi_rmat_tmp == NULL) ... else of rmat*/
  /* End of cleaning variable rmat */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_m2av ******************************/

/********************************** sla_map **********************************/
static char doc_f2py_rout_slalib_sla_map[] = "\
Function signature:\n\
  ra,da = sla_map(rm,dm,pr,pd,px,rv,eq,date)\n\
Required arguments:\n"
"  rm : input float\n"
"  dm : input float\n"
"  pr : input float\n"
"  pd : input float\n"
"  px : input float\n"
"  rv : input float\n"
"  eq : input float\n"
"  date : input float\n"
"Return objects:\n"
"  ra : float\n"
"  da : float";
/* extern void F_FUNC_US(sla_map,SLA_MAP)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_map(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double rm = 0;
  PyObject *rm_capi = Py_None;
  double dm = 0;
  PyObject *dm_capi = Py_None;
  double pr = 0;
  PyObject *pr_capi = Py_None;
  double pd = 0;
  PyObject *pd_capi = Py_None;
  double px = 0;
  PyObject *px_capi = Py_None;
  double rv = 0;
  PyObject *rv_capi = Py_None;
  double eq = 0;
  PyObject *eq_capi = Py_None;
  double date = 0;
  PyObject *date_capi = Py_None;
  double ra = 0;
  double da = 0;
  static char *capi_kwlist[] = {"rm","dm","pr","pd","px","rv","eq","date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOO|:slalib.sla_map",\
    capi_kwlist,&rm_capi,&dm_capi,&pr_capi,&pd_capi,&px_capi,&rv_capi,&eq_capi,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable pr */
    f2py_success = double_from_pyobj(&pr,pr_capi,"slalib.sla_map() 3rd argument (pr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rv */
    f2py_success = double_from_pyobj(&rv,rv_capi,"slalib.sla_map() 6th argument (rv) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dm */
    f2py_success = double_from_pyobj(&dm,dm_capi,"slalib.sla_map() 2nd argument (dm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable px */
    f2py_success = double_from_pyobj(&px,px_capi,"slalib.sla_map() 5th argument (px) can't be converted to double");
  if (f2py_success) {
  /* Processing variable da */
  /* Processing variable ra */
  /* Processing variable pd */
    f2py_success = double_from_pyobj(&pd,pd_capi,"slalib.sla_map() 4th argument (pd) can't be converted to double");
  if (f2py_success) {
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_map() 8th argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rm */
    f2py_success = double_from_pyobj(&rm,rm_capi,"slalib.sla_map() 1st argument (rm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable eq */
    f2py_success = double_from_pyobj(&eq,eq_capi,"slalib.sla_map() 7th argument (eq) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&rm,&dm,&pr,&pd,&px,&rv,&eq,&date,&ra,&da);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",ra,da);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of eq*/
  /* End of cleaning variable eq */
  } /*if (f2py_success) of rm*/
  /* End of cleaning variable rm */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
  } /*if (f2py_success) of pd*/
  /* End of cleaning variable pd */
  /* End of cleaning variable ra */
  /* End of cleaning variable da */
  } /*if (f2py_success) of px*/
  /* End of cleaning variable px */
  } /*if (f2py_success) of dm*/
  /* End of cleaning variable dm */
  } /*if (f2py_success) of rv*/
  /* End of cleaning variable rv */
  } /*if (f2py_success) of pr*/
  /* End of cleaning variable pr */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_map *******************************/

/********************************* sla_mappa *********************************/
static char doc_f2py_rout_slalib_sla_mappa[] = "\
Function signature:\n\
  amprms = sla_mappa(eq,date)\n\
Required arguments:\n"
"  eq : input float\n"
"  date : input float\n"
"Return objects:\n"
"  amprms : rank-1 array('d') with bounds (21)";
/* extern void F_FUNC_US(sla_mappa,SLA_MAPPA)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_mappa(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double eq = 0;
  PyObject *eq_capi = Py_None;
  double date = 0;
  PyObject *date_capi = Py_None;
  double *amprms = NULL;
  npy_intp amprms_Dims[1] = {-1};
  const int amprms_Rank = 1;
  PyArrayObject *capi_amprms_tmp = NULL;
  int capi_amprms_intent = 0;
  static char *capi_kwlist[] = {"eq","date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_mappa",\
    capi_kwlist,&eq_capi,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_mappa() 2nd argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable eq */
    f2py_success = double_from_pyobj(&eq,eq_capi,"slalib.sla_mappa() 1st argument (eq) can't be converted to double");
  if (f2py_success) {
  /* Processing variable amprms */
  amprms_Dims[0]=21;
  capi_amprms_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_amprms_tmp = array_from_pyobj(PyArray_DOUBLE,amprms_Dims,amprms_Rank,capi_amprms_intent,Py_None);
  if (capi_amprms_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `amprms' of slalib.sla_mappa to C/Fortran array" );
  } else {
    amprms = (double *)(capi_amprms_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&eq,&date,amprms);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_amprms_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_amprms_tmp == NULL) ... else of amprms*/
  /* End of cleaning variable amprms */
  } /*if (f2py_success) of eq*/
  /* End of cleaning variable eq */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_mappa ******************************/

/********************************* sla_mapqk *********************************/
static char doc_f2py_rout_slalib_sla_mapqk[] = "\
Function signature:\n\
  ra,da = sla_mapqk(rm,dm,pr,pd,px,rv,amprms)\n\
Required arguments:\n"
"  rm : input float\n"
"  dm : input float\n"
"  pr : input float\n"
"  pd : input float\n"
"  px : input float\n"
"  rv : input float\n"
"  amprms : input rank-1 array('d') with bounds (21)\n"
"Return objects:\n"
"  ra : float\n"
"  da : float";
/* extern void F_FUNC_US(sla_mapqk,SLA_MAPQK)(double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_mapqk(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double rm = 0;
  PyObject *rm_capi = Py_None;
  double dm = 0;
  PyObject *dm_capi = Py_None;
  double pr = 0;
  PyObject *pr_capi = Py_None;
  double pd = 0;
  PyObject *pd_capi = Py_None;
  double px = 0;
  PyObject *px_capi = Py_None;
  double rv = 0;
  PyObject *rv_capi = Py_None;
  double *amprms = NULL;
  npy_intp amprms_Dims[1] = {-1};
  const int amprms_Rank = 1;
  PyArrayObject *capi_amprms_tmp = NULL;
  int capi_amprms_intent = 0;
  PyObject *amprms_capi = Py_None;
  double ra = 0;
  double da = 0;
  static char *capi_kwlist[] = {"rm","dm","pr","pd","px","rv","amprms",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOO|:slalib.sla_mapqk",\
    capi_kwlist,&rm_capi,&dm_capi,&pr_capi,&pd_capi,&px_capi,&rv_capi,&amprms_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable pr */
    f2py_success = double_from_pyobj(&pr,pr_capi,"slalib.sla_mapqk() 3rd argument (pr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rv */
    f2py_success = double_from_pyobj(&rv,rv_capi,"slalib.sla_mapqk() 6th argument (rv) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dm */
    f2py_success = double_from_pyobj(&dm,dm_capi,"slalib.sla_mapqk() 2nd argument (dm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable px */
    f2py_success = double_from_pyobj(&px,px_capi,"slalib.sla_mapqk() 5th argument (px) can't be converted to double");
  if (f2py_success) {
  /* Processing variable da */
  /* Processing variable ra */
  /* Processing variable pd */
    f2py_success = double_from_pyobj(&pd,pd_capi,"slalib.sla_mapqk() 4th argument (pd) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rm */
    f2py_success = double_from_pyobj(&rm,rm_capi,"slalib.sla_mapqk() 1st argument (rm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable amprms */
  amprms_Dims[0]=21;
  capi_amprms_intent |= F2PY_INTENT_IN;
  capi_amprms_tmp = array_from_pyobj(PyArray_DOUBLE,amprms_Dims,amprms_Rank,capi_amprms_intent,amprms_capi);
  if (capi_amprms_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 7th argument `amprms' of slalib.sla_mapqk to C/Fortran array" );
  } else {
    amprms = (double *)(capi_amprms_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&rm,&dm,&pr,&pd,&px,&rv,amprms,&ra,&da);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",ra,da);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_amprms_tmp!=amprms_capi) {
    Py_XDECREF(capi_amprms_tmp); }
  }  /*if (capi_amprms_tmp == NULL) ... else of amprms*/
  /* End of cleaning variable amprms */
  } /*if (f2py_success) of rm*/
  /* End of cleaning variable rm */
  } /*if (f2py_success) of pd*/
  /* End of cleaning variable pd */
  /* End of cleaning variable ra */
  /* End of cleaning variable da */
  } /*if (f2py_success) of px*/
  /* End of cleaning variable px */
  } /*if (f2py_success) of dm*/
  /* End of cleaning variable dm */
  } /*if (f2py_success) of rv*/
  /* End of cleaning variable rv */
  } /*if (f2py_success) of pr*/
  /* End of cleaning variable pr */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_mapqk ******************************/

/********************************* sla_mapqkz *********************************/
static char doc_f2py_rout_slalib_sla_mapqkz[] = "\
Function signature:\n\
  ra,da = sla_mapqkz(rm,dm,amprms)\n\
Required arguments:\n"
"  rm : input float\n"
"  dm : input float\n"
"  amprms : input rank-1 array('d') with bounds (21)\n"
"Return objects:\n"
"  ra : float\n"
"  da : float";
/* extern void F_FUNC_US(sla_mapqkz,SLA_MAPQKZ)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_mapqkz(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double rm = 0;
  PyObject *rm_capi = Py_None;
  double dm = 0;
  PyObject *dm_capi = Py_None;
  double *amprms = NULL;
  npy_intp amprms_Dims[1] = {-1};
  const int amprms_Rank = 1;
  PyArrayObject *capi_amprms_tmp = NULL;
  int capi_amprms_intent = 0;
  PyObject *amprms_capi = Py_None;
  double ra = 0;
  double da = 0;
  static char *capi_kwlist[] = {"rm","dm","amprms",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_mapqkz",\
    capi_kwlist,&rm_capi,&dm_capi,&amprms_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rm */
    f2py_success = double_from_pyobj(&rm,rm_capi,"slalib.sla_mapqkz() 1st argument (rm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dm */
    f2py_success = double_from_pyobj(&dm,dm_capi,"slalib.sla_mapqkz() 2nd argument (dm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ra */
  /* Processing variable amprms */
  amprms_Dims[0]=21;
  capi_amprms_intent |= F2PY_INTENT_IN;
  capi_amprms_tmp = array_from_pyobj(PyArray_DOUBLE,amprms_Dims,amprms_Rank,capi_amprms_intent,amprms_capi);
  if (capi_amprms_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `amprms' of slalib.sla_mapqkz to C/Fortran array" );
  } else {
    amprms = (double *)(capi_amprms_tmp->data);

  /* Processing variable da */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&rm,&dm,amprms,&ra,&da);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",ra,da);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable da */
  if((PyObject *)capi_amprms_tmp!=amprms_capi) {
    Py_XDECREF(capi_amprms_tmp); }
  }  /*if (capi_amprms_tmp == NULL) ... else of amprms*/
  /* End of cleaning variable amprms */
  /* End of cleaning variable ra */
  } /*if (f2py_success) of dm*/
  /* End of cleaning variable dm */
  } /*if (f2py_success) of rm*/
  /* End of cleaning variable rm */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_mapqkz *****************************/

/********************************** sla_moon **********************************/
static char doc_f2py_rout_slalib_sla_moon[] = "\
Function signature:\n\
  pv = sla_moon(iy,id,fd)\n\
Required arguments:\n"
"  iy : input int\n"
"  id : input int\n"
"  fd : input float\n"
"Return objects:\n"
"  pv : rank-1 array('f') with bounds (6)";
/* extern void F_FUNC_US(sla_moon,SLA_MOON)(int*,int*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_moon(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int iy = 0;
  PyObject *iy_capi = Py_None;
  int id = 0;
  PyObject *id_capi = Py_None;
  float fd = 0;
  PyObject *fd_capi = Py_None;
  float *pv = NULL;
  npy_intp pv_Dims[1] = {-1};
  const int pv_Rank = 1;
  PyArrayObject *capi_pv_tmp = NULL;
  int capi_pv_intent = 0;
  static char *capi_kwlist[] = {"iy","id","fd",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_moon",\
    capi_kwlist,&iy_capi,&id_capi,&fd_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable iy */
    f2py_success = int_from_pyobj(&iy,iy_capi,"slalib.sla_moon() 1st argument (iy) can't be converted to int");
  if (f2py_success) {
  /* Processing variable fd */
    f2py_success = float_from_pyobj(&fd,fd_capi,"slalib.sla_moon() 3rd argument (fd) can't be converted to float");
  if (f2py_success) {
  /* Processing variable pv */
  pv_Dims[0]=6;
  capi_pv_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_pv_tmp = array_from_pyobj(PyArray_FLOAT,pv_Dims,pv_Rank,capi_pv_intent,Py_None);
  if (capi_pv_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `pv' of slalib.sla_moon to C/Fortran array" );
  } else {
    pv = (float *)(capi_pv_tmp->data);

  /* Processing variable id */
    f2py_success = int_from_pyobj(&id,id_capi,"slalib.sla_moon() 2nd argument (id) can't be converted to int");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&iy,&id,&fd,pv);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_pv_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of id*/
  /* End of cleaning variable id */
  }  /*if (capi_pv_tmp == NULL) ... else of pv*/
  /* End of cleaning variable pv */
  } /*if (f2py_success) of fd*/
  /* End of cleaning variable fd */
  } /*if (f2py_success) of iy*/
  /* End of cleaning variable iy */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_moon ******************************/

/********************************** sla_mxm **********************************/
static char doc_f2py_rout_slalib_sla_mxm[] = "\
Function signature:\n\
  c = sla_mxm(a,b)\n\
Required arguments:\n"
"  a : input rank-2 array('f') with bounds (3,3)\n"
"  b : input rank-2 array('f') with bounds (3,3)\n"
"Return objects:\n"
"  c : rank-2 array('f') with bounds (3,3)";
/* extern void F_FUNC_US(sla_mxm,SLA_MXM)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_mxm(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float *a = NULL;
  npy_intp a_Dims[2] = {-1, -1};
  const int a_Rank = 2;
  PyArrayObject *capi_a_tmp = NULL;
  int capi_a_intent = 0;
  PyObject *a_capi = Py_None;
  float *b = NULL;
  npy_intp b_Dims[2] = {-1, -1};
  const int b_Rank = 2;
  PyArrayObject *capi_b_tmp = NULL;
  int capi_b_intent = 0;
  PyObject *b_capi = Py_None;
  float *c = NULL;
  npy_intp c_Dims[2] = {-1, -1};
  const int c_Rank = 2;
  PyArrayObject *capi_c_tmp = NULL;
  int capi_c_intent = 0;
  static char *capi_kwlist[] = {"a","b",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_mxm",\
    capi_kwlist,&a_capi,&b_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
  a_Dims[0]=3,a_Dims[1]=3;
  capi_a_intent |= F2PY_INTENT_IN;
  capi_a_tmp = array_from_pyobj(PyArray_FLOAT,a_Dims,a_Rank,capi_a_intent,a_capi);
  if (capi_a_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `a' of slalib.sla_mxm to C/Fortran array" );
  } else {
    a = (float *)(capi_a_tmp->data);

  /* Processing variable c */
  c_Dims[0]=3,c_Dims[1]=3;
  capi_c_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_c_tmp = array_from_pyobj(PyArray_FLOAT,c_Dims,c_Rank,capi_c_intent,Py_None);
  if (capi_c_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `c' of slalib.sla_mxm to C/Fortran array" );
  } else {
    c = (float *)(capi_c_tmp->data);

  /* Processing variable b */
  b_Dims[0]=3,b_Dims[1]=3;
  capi_b_intent |= F2PY_INTENT_IN;
  capi_b_tmp = array_from_pyobj(PyArray_FLOAT,b_Dims,b_Rank,capi_b_intent,b_capi);
  if (capi_b_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `b' of slalib.sla_mxm to C/Fortran array" );
  } else {
    b = (float *)(capi_b_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(a,b,c);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_c_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_b_tmp!=b_capi) {
    Py_XDECREF(capi_b_tmp); }
  }  /*if (capi_b_tmp == NULL) ... else of b*/
  /* End of cleaning variable b */
  }  /*if (capi_c_tmp == NULL) ... else of c*/
  /* End of cleaning variable c */
  if((PyObject *)capi_a_tmp!=a_capi) {
    Py_XDECREF(capi_a_tmp); }
  }  /*if (capi_a_tmp == NULL) ... else of a*/
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_mxm *******************************/

/********************************** sla_mxv **********************************/
static char doc_f2py_rout_slalib_sla_mxv[] = "\
Function signature:\n\
  vb = sla_mxv(rm,va)\n\
Required arguments:\n"
"  rm : input rank-2 array('f') with bounds (3,3)\n"
"  va : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  vb : rank-1 array('f') with bounds (3)";
/* extern void F_FUNC_US(sla_mxv,SLA_MXV)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_mxv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float *rm = NULL;
  npy_intp rm_Dims[2] = {-1, -1};
  const int rm_Rank = 2;
  PyArrayObject *capi_rm_tmp = NULL;
  int capi_rm_intent = 0;
  PyObject *rm_capi = Py_None;
  float *va = NULL;
  npy_intp va_Dims[1] = {-1};
  const int va_Rank = 1;
  PyArrayObject *capi_va_tmp = NULL;
  int capi_va_intent = 0;
  PyObject *va_capi = Py_None;
  float *vb = NULL;
  npy_intp vb_Dims[1] = {-1};
  const int vb_Rank = 1;
  PyArrayObject *capi_vb_tmp = NULL;
  int capi_vb_intent = 0;
  static char *capi_kwlist[] = {"rm","va",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_mxv",\
    capi_kwlist,&rm_capi,&va_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rm */
  rm_Dims[0]=3,rm_Dims[1]=3;
  capi_rm_intent |= F2PY_INTENT_IN;
  capi_rm_tmp = array_from_pyobj(PyArray_FLOAT,rm_Dims,rm_Rank,capi_rm_intent,rm_capi);
  if (capi_rm_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `rm' of slalib.sla_mxv to C/Fortran array" );
  } else {
    rm = (float *)(capi_rm_tmp->data);

  /* Processing variable vb */
  vb_Dims[0]=3;
  capi_vb_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_vb_tmp = array_from_pyobj(PyArray_FLOAT,vb_Dims,vb_Rank,capi_vb_intent,Py_None);
  if (capi_vb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `vb' of slalib.sla_mxv to C/Fortran array" );
  } else {
    vb = (float *)(capi_vb_tmp->data);

  /* Processing variable va */
  va_Dims[0]=3;
  capi_va_intent |= F2PY_INTENT_IN;
  capi_va_tmp = array_from_pyobj(PyArray_FLOAT,va_Dims,va_Rank,capi_va_intent,va_capi);
  if (capi_va_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `va' of slalib.sla_mxv to C/Fortran array" );
  } else {
    va = (float *)(capi_va_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(rm,va,vb);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_vb_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_va_tmp!=va_capi) {
    Py_XDECREF(capi_va_tmp); }
  }  /*if (capi_va_tmp == NULL) ... else of va*/
  /* End of cleaning variable va */
  }  /*if (capi_vb_tmp == NULL) ... else of vb*/
  /* End of cleaning variable vb */
  if((PyObject *)capi_rm_tmp!=rm_capi) {
    Py_XDECREF(capi_rm_tmp); }
  }  /*if (capi_rm_tmp == NULL) ... else of rm*/
  /* End of cleaning variable rm */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_mxv *******************************/

/********************************* sla_nutc80 *********************************/
static char doc_f2py_rout_slalib_sla_nutc80[] = "\
Function signature:\n\
  dpsi,deps,eps0 = sla_nutc80(date)\n\
Required arguments:\n"
"  date : input float\n"
"Return objects:\n"
"  dpsi : float\n"
"  deps : float\n"
"  eps0 : float";
/* extern void F_FUNC_US(sla_nutc80,SLA_NUTC80)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_nutc80(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double dpsi = 0;
  double deps = 0;
  double eps0 = 0;
  static char *capi_kwlist[] = {"date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_nutc80",\
    capi_kwlist,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_nutc80() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dpsi */
  /* Processing variable deps */
  /* Processing variable eps0 */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,&dpsi,&deps,&eps0);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ddd",dpsi,deps,eps0);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable eps0 */
  /* End of cleaning variable deps */
  /* End of cleaning variable dpsi */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_nutc80 *****************************/

/********************************** sla_nutc **********************************/
static char doc_f2py_rout_slalib_sla_nutc[] = "\
Function signature:\n\
  dpsi,deps,eps0 = sla_nutc(date)\n\
Required arguments:\n"
"  date : input float\n"
"Return objects:\n"
"  dpsi : float\n"
"  deps : float\n"
"  eps0 : float";
/* extern void F_FUNC_US(sla_nutc,SLA_NUTC)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_nutc(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double dpsi = 0;
  double deps = 0;
  double eps0 = 0;
  static char *capi_kwlist[] = {"date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_nutc",\
    capi_kwlist,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_nutc() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dpsi */
  /* Processing variable deps */
  /* Processing variable eps0 */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,&dpsi,&deps,&eps0);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ddd",dpsi,deps,eps0);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable eps0 */
  /* End of cleaning variable deps */
  /* End of cleaning variable dpsi */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_nutc ******************************/

/********************************** sla_nut **********************************/
static char doc_f2py_rout_slalib_sla_nut[] = "\
Function signature:\n\
  rmatn = sla_nut(date)\n\
Required arguments:\n"
"  date : input float\n"
"Return objects:\n"
"  rmatn : rank-2 array('d') with bounds (3,3)";
/* extern void F_FUNC_US(sla_nut,SLA_NUT)(double*,double*); */
static PyObject *f2py_rout_slalib_sla_nut(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double *rmatn = NULL;
  npy_intp rmatn_Dims[2] = {-1, -1};
  const int rmatn_Rank = 2;
  PyArrayObject *capi_rmatn_tmp = NULL;
  int capi_rmatn_intent = 0;
  static char *capi_kwlist[] = {"date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_nut",\
    capi_kwlist,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_nut() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rmatn */
  rmatn_Dims[0]=3,rmatn_Dims[1]=3;
  capi_rmatn_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_rmatn_tmp = array_from_pyobj(PyArray_DOUBLE,rmatn_Dims,rmatn_Rank,capi_rmatn_intent,Py_None);
  if (capi_rmatn_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `rmatn' of slalib.sla_nut to C/Fortran array" );
  } else {
    rmatn = (double *)(capi_rmatn_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,rmatn);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_rmatn_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_rmatn_tmp == NULL) ... else of rmatn*/
  /* End of cleaning variable rmatn */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_nut *******************************/

/********************************** sla_oap **********************************/
static char doc_f2py_rout_slalib_sla_oap[] = "\
Function signature:\n\
  rap,dap = sla_oap(type_bn,ob1,ob2,date,dut,elongm,phim,hm,xp,yp,tdk,pmb,rh,wl,tlr)\n\
Required arguments:\n"
"  type_bn : input string(len=-1)\n"
"  ob1 : input float\n"
"  ob2 : input float\n"
"  date : input float\n"
"  dut : input float\n"
"  elongm : input float\n"
"  phim : input float\n"
"  hm : input float\n"
"  xp : input float\n"
"  yp : input float\n"
"  tdk : input float\n"
"  pmb : input float\n"
"  rh : input float\n"
"  wl : input float\n"
"  tlr : input float\n"
"Return objects:\n"
"  rap : float\n"
"  dap : float";
/* extern void F_FUNC_US(sla_oap,SLA_OAP)(string,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,size_t); */
static PyObject *f2py_rout_slalib_sla_oap(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string type_bn = NULL;
  int slen(type_bn);
  PyObject *type_bn_capi = Py_None;
  double ob1 = 0;
  PyObject *ob1_capi = Py_None;
  double ob2 = 0;
  PyObject *ob2_capi = Py_None;
  double date = 0;
  PyObject *date_capi = Py_None;
  double dut = 0;
  PyObject *dut_capi = Py_None;
  double elongm = 0;
  PyObject *elongm_capi = Py_None;
  double phim = 0;
  PyObject *phim_capi = Py_None;
  double hm = 0;
  PyObject *hm_capi = Py_None;
  double xp = 0;
  PyObject *xp_capi = Py_None;
  double yp = 0;
  PyObject *yp_capi = Py_None;
  double tdk = 0;
  PyObject *tdk_capi = Py_None;
  double pmb = 0;
  PyObject *pmb_capi = Py_None;
  double rh = 0;
  PyObject *rh_capi = Py_None;
  double wl = 0;
  PyObject *wl_capi = Py_None;
  double tlr = 0;
  PyObject *tlr_capi = Py_None;
  double rap = 0;
  double dap = 0;
  static char *capi_kwlist[] = {"type_bn","ob1","ob2","date","dut","elongm","phim","hm","xp","yp","tdk","pmb","rh","wl","tlr",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOOOOOOOOO|:slalib.sla_oap",\
    capi_kwlist,&type_bn_capi,&ob1_capi,&ob2_capi,&date_capi,&dut_capi,&elongm_capi,&phim_capi,&hm_capi,&xp_capi,&yp_capi,&tdk_capi,&pmb_capi,&rh_capi,&wl_capi,&tlr_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable tdk */
    f2py_success = double_from_pyobj(&tdk,tdk_capi,"slalib.sla_oap() 11st argument (tdk) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ob2 */
    f2py_success = double_from_pyobj(&ob2,ob2_capi,"slalib.sla_oap() 3rd argument (ob2) can't be converted to double");
  if (f2py_success) {
  /* Processing variable pmb */
    f2py_success = double_from_pyobj(&pmb,pmb_capi,"slalib.sla_oap() 12nd argument (pmb) can't be converted to double");
  if (f2py_success) {
  /* Processing variable wl */
    f2py_success = double_from_pyobj(&wl,wl_capi,"slalib.sla_oap() 14th argument (wl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dap */
  /* Processing variable rap */
  /* Processing variable hm */
    f2py_success = double_from_pyobj(&hm,hm_capi,"slalib.sla_oap() 8th argument (hm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_oap() 4th argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable yp */
    f2py_success = double_from_pyobj(&yp,yp_capi,"slalib.sla_oap() 10th argument (yp) can't be converted to double");
  if (f2py_success) {
  /* Processing variable xp */
    f2py_success = double_from_pyobj(&xp,xp_capi,"slalib.sla_oap() 9th argument (xp) can't be converted to double");
  if (f2py_success) {
  /* Processing variable tlr */
    f2py_success = double_from_pyobj(&tlr,tlr_capi,"slalib.sla_oap() 15th argument (tlr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dut */
    f2py_success = double_from_pyobj(&dut,dut_capi,"slalib.sla_oap() 5th argument (dut) can't be converted to double");
  if (f2py_success) {
  /* Processing variable phim */
    f2py_success = double_from_pyobj(&phim,phim_capi,"slalib.sla_oap() 7th argument (phim) can't be converted to double");
  if (f2py_success) {
  /* Processing variable elongm */
    f2py_success = double_from_pyobj(&elongm,elongm_capi,"slalib.sla_oap() 6th argument (elongm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable type_bn */
  slen(type_bn) = -1;
  f2py_success = string_from_pyobj(&type_bn,&slen(type_bn),"",type_bn_capi,"string_from_pyobj failed in converting 1st argument `type_bn' of slalib.sla_oap to C string");
  if (f2py_success) {
  /* Processing variable rh */
    f2py_success = double_from_pyobj(&rh,rh_capi,"slalib.sla_oap() 13rd argument (rh) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ob1 */
    f2py_success = double_from_pyobj(&ob1,ob1_capi,"slalib.sla_oap() 2nd argument (ob1) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(type_bn,&ob1,&ob2,&date,&dut,&elongm,&phim,&hm,&xp,&yp,&tdk,&pmb,&rh,&wl,&tlr,&rap,&dap,slen(type_bn));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",rap,dap);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of ob1*/
  /* End of cleaning variable ob1 */
  } /*if (f2py_success) of rh*/
  /* End of cleaning variable rh */
    STRINGFREE(type_bn);
  }  /*if (f2py_success) of type_bn*/
  /* End of cleaning variable type_bn */
  } /*if (f2py_success) of elongm*/
  /* End of cleaning variable elongm */
  } /*if (f2py_success) of phim*/
  /* End of cleaning variable phim */
  } /*if (f2py_success) of dut*/
  /* End of cleaning variable dut */
  } /*if (f2py_success) of tlr*/
  /* End of cleaning variable tlr */
  } /*if (f2py_success) of xp*/
  /* End of cleaning variable xp */
  } /*if (f2py_success) of yp*/
  /* End of cleaning variable yp */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
  } /*if (f2py_success) of hm*/
  /* End of cleaning variable hm */
  /* End of cleaning variable rap */
  /* End of cleaning variable dap */
  } /*if (f2py_success) of wl*/
  /* End of cleaning variable wl */
  } /*if (f2py_success) of pmb*/
  /* End of cleaning variable pmb */
  } /*if (f2py_success) of ob2*/
  /* End of cleaning variable ob2 */
  } /*if (f2py_success) of tdk*/
  /* End of cleaning variable tdk */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_oap *******************************/

/********************************* sla_oapqk *********************************/
static char doc_f2py_rout_slalib_sla_oapqk[] = "\
Function signature:\n\
  rap,dap = sla_oapqk(type_bn,ob1,ob2,aoprms)\n\
Required arguments:\n"
"  type_bn : input string(len=-1)\n"
"  ob1 : input float\n"
"  ob2 : input float\n"
"  aoprms : input rank-1 array('d') with bounds (14)\n"
"Return objects:\n"
"  rap : float\n"
"  dap : float";
/* extern void F_FUNC_US(sla_oapqk,SLA_OAPQK)(string,double*,double*,double*,double*,double*,size_t); */
static PyObject *f2py_rout_slalib_sla_oapqk(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,double*,double*,double*,double*,double*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string type_bn = NULL;
  int slen(type_bn);
  PyObject *type_bn_capi = Py_None;
  double ob1 = 0;
  PyObject *ob1_capi = Py_None;
  double ob2 = 0;
  PyObject *ob2_capi = Py_None;
  double *aoprms = NULL;
  npy_intp aoprms_Dims[1] = {-1};
  const int aoprms_Rank = 1;
  PyArrayObject *capi_aoprms_tmp = NULL;
  int capi_aoprms_intent = 0;
  PyObject *aoprms_capi = Py_None;
  double rap = 0;
  double dap = 0;
  static char *capi_kwlist[] = {"type_bn","ob1","ob2","aoprms",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_oapqk",\
    capi_kwlist,&type_bn_capi,&ob1_capi,&ob2_capi,&aoprms_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable aoprms */
  aoprms_Dims[0]=14;
  capi_aoprms_intent |= F2PY_INTENT_IN;
  capi_aoprms_tmp = array_from_pyobj(PyArray_DOUBLE,aoprms_Dims,aoprms_Rank,capi_aoprms_intent,aoprms_capi);
  if (capi_aoprms_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 4th argument `aoprms' of slalib.sla_oapqk to C/Fortran array" );
  } else {
    aoprms = (double *)(capi_aoprms_tmp->data);

  /* Processing variable dap */
  /* Processing variable rap */
  /* Processing variable ob2 */
    f2py_success = double_from_pyobj(&ob2,ob2_capi,"slalib.sla_oapqk() 3rd argument (ob2) can't be converted to double");
  if (f2py_success) {
  /* Processing variable type_bn */
  slen(type_bn) = -1;
  f2py_success = string_from_pyobj(&type_bn,&slen(type_bn),"",type_bn_capi,"string_from_pyobj failed in converting 1st argument `type_bn' of slalib.sla_oapqk to C string");
  if (f2py_success) {
  /* Processing variable ob1 */
    f2py_success = double_from_pyobj(&ob1,ob1_capi,"slalib.sla_oapqk() 2nd argument (ob1) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(type_bn,&ob1,&ob2,aoprms,&rap,&dap,slen(type_bn));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",rap,dap);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of ob1*/
  /* End of cleaning variable ob1 */
    STRINGFREE(type_bn);
  }  /*if (f2py_success) of type_bn*/
  /* End of cleaning variable type_bn */
  } /*if (f2py_success) of ob2*/
  /* End of cleaning variable ob2 */
  /* End of cleaning variable rap */
  /* End of cleaning variable dap */
  if((PyObject *)capi_aoprms_tmp!=aoprms_capi) {
    Py_XDECREF(capi_aoprms_tmp); }
  }  /*if (capi_aoprms_tmp == NULL) ... else of aoprms*/
  /* End of cleaning variable aoprms */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_oapqk ******************************/

/********************************** sla_obs **********************************/
static char doc_f2py_rout_slalib_sla_obs[] = "\
Function signature:\n\
  c,name,w,p,h = sla_obs(n,c)\n\
Required arguments:\n"
"  n : input int\n"
"  c : input string(len=-1)\n"
"Return objects:\n"
"  c : string(len=-1)\n"
"  name : string(len=40)\n"
"  w : float\n"
"  p : float\n"
"  h : float";
/* extern void F_FUNC_US(sla_obs,SLA_OBS)(int*,string,string,double*,double*,double*,size_t,size_t); */
static PyObject *f2py_rout_slalib_sla_obs(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,string,string,double*,double*,double*,size_t,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int n = 0;
  PyObject *n_capi = Py_None;
  string c = NULL;
  int slen(c);
  PyObject *c_capi = Py_None;
  string name = NULL;
  int slen(name);
  PyObject *name_capi = Py_None;
  double w = 0;
  double p = 0;
  double h = 0;
  static char *capi_kwlist[] = {"n","c",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_obs",\
    capi_kwlist,&n_capi,&c_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable p */
  /* Processing variable c */
  slen(c) = -1;
  f2py_success = string_from_pyobj(&c,&slen(c),"",c_capi,"string_from_pyobj failed in converting 2nd argument `c' of slalib.sla_obs to C string");
  if (f2py_success) {
  /* Processing variable name */
  slen(name) = 40;
  f2py_success = string_from_pyobj(&name,&slen(name),"",name_capi,"string_from_pyobj failed in converting hidden `name' of slalib.sla_obs to C string");
  if (f2py_success) {
  /* Processing variable w */
  /* Processing variable h */
  /* Processing variable n */
    f2py_success = int_from_pyobj(&n,n_capi,"slalib.sla_obs() 1st argument (n) can't be converted to int");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&n,c,name,&w,&p,&h,slen(c),slen(name));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("zzddd",c,name,w,p,h);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of n*/
  /* End of cleaning variable n */
  /* End of cleaning variable h */
  /* End of cleaning variable w */
    STRINGFREE(name);
  }  /*if (f2py_success) of name*/
  /* End of cleaning variable name */
    STRINGFREE(c);
  }  /*if (f2py_success) of c*/
  /* End of cleaning variable c */
  /* End of cleaning variable p */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_obs *******************************/

/*********************************** sla_pa ***********************************/
static char doc_f2py_rout_slalib_sla_pa[] = "\
Function signature:\n\
  sla_pa = sla_pa(ha,dec,phi)\n\
Required arguments:\n"
"  ha : input float\n"
"  dec : input float\n"
"  phi : input float\n"
"Return objects:\n"
"  sla_pa : float";
/* extern void F_WRAPPEDFUNC_US(sla_pa,SLA_PA)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_pa(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_pa = 0;
  double ha = 0;
  PyObject *ha_capi = Py_None;
  double dec = 0;
  PyObject *dec_capi = Py_None;
  double phi = 0;
  PyObject *phi_capi = Py_None;
  static char *capi_kwlist[] = {"ha","dec","phi",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_pa",\
    capi_kwlist,&ha_capi,&dec_capi,&phi_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable phi */
    f2py_success = double_from_pyobj(&phi,phi_capi,"slalib.sla_pa() 3rd argument (phi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ha */
    f2py_success = double_from_pyobj(&ha,ha_capi,"slalib.sla_pa() 1st argument (ha) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dec */
    f2py_success = double_from_pyobj(&dec,dec_capi,"slalib.sla_pa() 2nd argument (dec) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_pa */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_pa,&ha,&dec,&phi);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_pa);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_pa */
  } /*if (f2py_success) of dec*/
  /* End of cleaning variable dec */
  } /*if (f2py_success) of ha*/
  /* End of cleaning variable ha */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_pa *******************************/

/********************************** sla_pav **********************************/
static char doc_f2py_rout_slalib_sla_pav[] = "\
Function signature:\n\
  sla_pav = sla_pav(v1,v2)\n\
Required arguments:\n"
"  v1 : input rank-1 array('f') with bounds (3)\n"
"  v2 : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  sla_pav : float";
/* extern void F_WRAPPEDFUNC_US(sla_pav,SLA_PAV)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_pav(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_pav = 0;
  float *v1 = NULL;
  npy_intp v1_Dims[1] = {-1};
  const int v1_Rank = 1;
  PyArrayObject *capi_v1_tmp = NULL;
  int capi_v1_intent = 0;
  PyObject *v1_capi = Py_None;
  float *v2 = NULL;
  npy_intp v2_Dims[1] = {-1};
  const int v2_Rank = 1;
  PyArrayObject *capi_v2_tmp = NULL;
  int capi_v2_intent = 0;
  PyObject *v2_capi = Py_None;
  static char *capi_kwlist[] = {"v1","v2",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_pav",\
    capi_kwlist,&v1_capi,&v2_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable v1 */
  v1_Dims[0]=3;
  capi_v1_intent |= F2PY_INTENT_IN;
  capi_v1_tmp = array_from_pyobj(PyArray_FLOAT,v1_Dims,v1_Rank,capi_v1_intent,v1_capi);
  if (capi_v1_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v1' of slalib.sla_pav to C/Fortran array" );
  } else {
    v1 = (float *)(capi_v1_tmp->data);

  /* Processing variable v2 */
  v2_Dims[0]=3;
  capi_v2_intent |= F2PY_INTENT_IN;
  capi_v2_tmp = array_from_pyobj(PyArray_FLOAT,v2_Dims,v2_Rank,capi_v2_intent,v2_capi);
  if (capi_v2_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `v2' of slalib.sla_pav to C/Fortran array" );
  } else {
    v2 = (float *)(capi_v2_tmp->data);

  /* Processing variable sla_pav */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_pav,v1,v2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_pav);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_pav */
  if((PyObject *)capi_v2_tmp!=v2_capi) {
    Py_XDECREF(capi_v2_tmp); }
  }  /*if (capi_v2_tmp == NULL) ... else of v2*/
  /* End of cleaning variable v2 */
  if((PyObject *)capi_v1_tmp!=v1_capi) {
    Py_XDECREF(capi_v1_tmp); }
  }  /*if (capi_v1_tmp == NULL) ... else of v1*/
  /* End of cleaning variable v1 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_pav *******************************/

/********************************** sla_pcd **********************************/
static char doc_f2py_rout_slalib_sla_pcd[] = "\
Function signature:\n\
  x,y = sla_pcd(disco,x,y)\n\
Required arguments:\n"
"  disco : input float\n"
"  x : input float\n"
"  y : input float\n"
"Return objects:\n"
"  x : float\n"
"  y : float";
/* extern void F_FUNC_US(sla_pcd,SLA_PCD)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_pcd(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double disco = 0;
  PyObject *disco_capi = Py_None;
  double x = 0;
  PyObject *x_capi = Py_None;
  double y = 0;
  PyObject *y_capi = Py_None;
  static char *capi_kwlist[] = {"disco","x","y",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_pcd",\
    capi_kwlist,&disco_capi,&x_capi,&y_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable y */
    f2py_success = double_from_pyobj(&y,y_capi,"slalib.sla_pcd() 3rd argument (y) can't be converted to double");
  if (f2py_success) {
  /* Processing variable x */
    f2py_success = double_from_pyobj(&x,x_capi,"slalib.sla_pcd() 2nd argument (x) can't be converted to double");
  if (f2py_success) {
  /* Processing variable disco */
    f2py_success = double_from_pyobj(&disco,disco_capi,"slalib.sla_pcd() 1st argument (disco) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&disco,&x,&y);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",x,y);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of disco*/
  /* End of cleaning variable disco */
  } /*if (f2py_success) of x*/
  /* End of cleaning variable x */
  } /*if (f2py_success) of y*/
  /* End of cleaning variable y */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_pcd *******************************/

/********************************* sla_pda2h *********************************/
static char doc_f2py_rout_slalib_sla_pda2h[] = "\
Function signature:\n\
  h1,j1,h2,j2 = sla_pda2h(p,d,a)\n\
Required arguments:\n"
"  p : input float\n"
"  d : input float\n"
"  a : input float\n"
"Return objects:\n"
"  h1 : float\n"
"  j1 : int\n"
"  h2 : float\n"
"  j2 : int";
/* extern void F_FUNC_US(sla_pda2h,SLA_PDA2H)(double*,double*,double*,double*,int*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_pda2h(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,int*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double p = 0;
  PyObject *p_capi = Py_None;
  double d = 0;
  PyObject *d_capi = Py_None;
  double a = 0;
  PyObject *a_capi = Py_None;
  double h1 = 0;
  int j1 = 0;
  double h2 = 0;
  int j2 = 0;
  static char *capi_kwlist[] = {"p","d","a",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_pda2h",\
    capi_kwlist,&p_capi,&d_capi,&a_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
    f2py_success = double_from_pyobj(&a,a_capi,"slalib.sla_pda2h() 3rd argument (a) can't be converted to double");
  if (f2py_success) {
  /* Processing variable p */
    f2py_success = double_from_pyobj(&p,p_capi,"slalib.sla_pda2h() 1st argument (p) can't be converted to double");
  if (f2py_success) {
  /* Processing variable d */
    f2py_success = double_from_pyobj(&d,d_capi,"slalib.sla_pda2h() 2nd argument (d) can't be converted to double");
  if (f2py_success) {
  /* Processing variable h2 */
  /* Processing variable h1 */
  /* Processing variable j1 */
  /* Processing variable j2 */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&p,&d,&a,&h1,&j1,&h2,&j2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("didi",h1,j1,h2,j2);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable j2 */
  /* End of cleaning variable j1 */
  /* End of cleaning variable h1 */
  /* End of cleaning variable h2 */
  } /*if (f2py_success) of d*/
  /* End of cleaning variable d */
  } /*if (f2py_success) of p*/
  /* End of cleaning variable p */
  } /*if (f2py_success) of a*/
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_pda2h ******************************/

/********************************* sla_pdq2h *********************************/
static char doc_f2py_rout_slalib_sla_pdq2h[] = "\
Function signature:\n\
  h1,j1,h2,j2 = sla_pdq2h(p,d,q)\n\
Required arguments:\n"
"  p : input float\n"
"  d : input float\n"
"  q : input float\n"
"Return objects:\n"
"  h1 : float\n"
"  j1 : int\n"
"  h2 : float\n"
"  j2 : int";
/* extern void F_FUNC_US(sla_pdq2h,SLA_PDQ2H)(double*,double*,double*,double*,int*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_pdq2h(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,int*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double p = 0;
  PyObject *p_capi = Py_None;
  double d = 0;
  PyObject *d_capi = Py_None;
  double q = 0;
  PyObject *q_capi = Py_None;
  double h1 = 0;
  int j1 = 0;
  double h2 = 0;
  int j2 = 0;
  static char *capi_kwlist[] = {"p","d","q",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_pdq2h",\
    capi_kwlist,&p_capi,&d_capi,&q_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable q */
    f2py_success = double_from_pyobj(&q,q_capi,"slalib.sla_pdq2h() 3rd argument (q) can't be converted to double");
  if (f2py_success) {
  /* Processing variable p */
    f2py_success = double_from_pyobj(&p,p_capi,"slalib.sla_pdq2h() 1st argument (p) can't be converted to double");
  if (f2py_success) {
  /* Processing variable d */
    f2py_success = double_from_pyobj(&d,d_capi,"slalib.sla_pdq2h() 2nd argument (d) can't be converted to double");
  if (f2py_success) {
  /* Processing variable h2 */
  /* Processing variable h1 */
  /* Processing variable j1 */
  /* Processing variable j2 */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&p,&d,&q,&h1,&j1,&h2,&j2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("didi",h1,j1,h2,j2);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable j2 */
  /* End of cleaning variable j1 */
  /* End of cleaning variable h1 */
  /* End of cleaning variable h2 */
  } /*if (f2py_success) of d*/
  /* End of cleaning variable d */
  } /*if (f2py_success) of p*/
  /* End of cleaning variable p */
  } /*if (f2py_success) of q*/
  /* End of cleaning variable q */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_pdq2h ******************************/

/********************************* sla_permut *********************************/
static char doc_f2py_rout_slalib_sla_permut[] = "\
Function signature:\n\
  istate,iorder,j = sla_permut(istate,[n])\n\
Required arguments:\n"
"  istate : input rank-1 array('i') with bounds (n)\n"
"Optional arguments:\n"
"  n := len(istate) input int\n"
"Return objects:\n"
"  istate : rank-1 array('i') with bounds (n)\n"
"  iorder : rank-1 array('i') with bounds (n)\n"
"  j : int";
/* extern void F_FUNC_US(sla_permut,SLA_PERMUT)(int*,int*,int*,int*); */
static PyObject *f2py_rout_slalib_sla_permut(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,int*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int n = 0;
  PyObject *n_capi = Py_None;
  int *istate = NULL;
  npy_intp istate_Dims[1] = {-1};
  const int istate_Rank = 1;
  PyArrayObject *capi_istate_tmp = NULL;
  int capi_istate_intent = 0;
  PyObject *istate_capi = Py_None;
  int *iorder = NULL;
  npy_intp iorder_Dims[1] = {-1};
  const int iorder_Rank = 1;
  PyArrayObject *capi_iorder_tmp = NULL;
  int capi_iorder_intent = 0;
  int j = 0;
  static char *capi_kwlist[] = {"istate","n",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|O:slalib.sla_permut",\
    capi_kwlist,&istate_capi,&n_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable istate */
  ;
  capi_istate_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_istate_tmp = array_from_pyobj(PyArray_INT,istate_Dims,istate_Rank,capi_istate_intent,istate_capi);
  if (capi_istate_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `istate' of slalib.sla_permut to C/Fortran array" );
  } else {
    istate = (int *)(capi_istate_tmp->data);

  /* Processing variable j */
  /* Processing variable n */
  if (n_capi == Py_None) n = len(istate); else
    f2py_success = int_from_pyobj(&n,n_capi,"slalib.sla_permut() 1st keyword (n) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(len(istate)>=n,"len(istate)>=n","1st keyword n","sla_permut:n=%d",n) {
  /* Processing variable iorder */
  iorder_Dims[0]=n;
  capi_iorder_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_iorder_tmp = array_from_pyobj(PyArray_INT,iorder_Dims,iorder_Rank,capi_iorder_intent,Py_None);
  if (capi_iorder_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `iorder' of slalib.sla_permut to C/Fortran array" );
  } else {
    iorder = (int *)(capi_iorder_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&n,istate,iorder,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("NNi",capi_istate_tmp,capi_iorder_tmp,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_iorder_tmp == NULL) ... else of iorder*/
  /* End of cleaning variable iorder */
  } /*CHECKSCALAR(len(istate)>=n)*/
  } /*if (f2py_success) of n*/
  /* End of cleaning variable n */
  /* End of cleaning variable j */
  }  /*if (capi_istate_tmp == NULL) ... else of istate*/
  /* End of cleaning variable istate */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_permut *****************************/

/********************************* sla_pertel *********************************/
static char doc_f2py_rout_slalib_sla_pertel[] = "\
Function signature:\n\
  epoch1,orbi1,anode1,perih1,aorq1,e1,am1,jstat = sla_pertel(jform,date0,date1,epoch0,orbi0,anode0,perih0,aorq0,e0,am0)\n\
Required arguments:\n"
"  jform : input int\n"
"  date0 : input float\n"
"  date1 : input float\n"
"  epoch0 : input float\n"
"  orbi0 : input float\n"
"  anode0 : input float\n"
"  perih0 : input float\n"
"  aorq0 : input float\n"
"  e0 : input float\n"
"  am0 : input float\n"
"Return objects:\n"
"  epoch1 : float\n"
"  orbi1 : float\n"
"  anode1 : float\n"
"  perih1 : float\n"
"  aorq1 : float\n"
"  e1 : float\n"
"  am1 : float\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_pertel,SLA_PERTEL)(int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_pertel(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int jform = 0;
  PyObject *jform_capi = Py_None;
  double date0 = 0;
  PyObject *date0_capi = Py_None;
  double date1 = 0;
  PyObject *date1_capi = Py_None;
  double epoch0 = 0;
  PyObject *epoch0_capi = Py_None;
  double orbi0 = 0;
  PyObject *orbi0_capi = Py_None;
  double anode0 = 0;
  PyObject *anode0_capi = Py_None;
  double perih0 = 0;
  PyObject *perih0_capi = Py_None;
  double aorq0 = 0;
  PyObject *aorq0_capi = Py_None;
  double e0 = 0;
  PyObject *e0_capi = Py_None;
  double am0 = 0;
  PyObject *am0_capi = Py_None;
  double epoch1 = 0;
  double orbi1 = 0;
  double anode1 = 0;
  double perih1 = 0;
  double aorq1 = 0;
  double e1 = 0;
  double am1 = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"jform","date0","date1","epoch0","orbi0","anode0","perih0","aorq0","e0","am0",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOOOO|:slalib.sla_pertel",\
    capi_kwlist,&jform_capi,&date0_capi,&date1_capi,&epoch0_capi,&orbi0_capi,&anode0_capi,&perih0_capi,&aorq0_capi,&e0_capi,&am0_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable anode1 */
  /* Processing variable anode0 */
    f2py_success = double_from_pyobj(&anode0,anode0_capi,"slalib.sla_pertel() 6th argument (anode0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable perih0 */
    f2py_success = double_from_pyobj(&perih0,perih0_capi,"slalib.sla_pertel() 7th argument (perih0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable perih1 */
  /* Processing variable epoch1 */
  /* Processing variable epoch0 */
    f2py_success = double_from_pyobj(&epoch0,epoch0_capi,"slalib.sla_pertel() 4th argument (epoch0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable am1 */
  /* Processing variable am0 */
    f2py_success = double_from_pyobj(&am0,am0_capi,"slalib.sla_pertel() 10th argument (am0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable e1 */
  /* Processing variable e0 */
    f2py_success = double_from_pyobj(&e0,e0_capi,"slalib.sla_pertel() 9th argument (e0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable date1 */
    f2py_success = double_from_pyobj(&date1,date1_capi,"slalib.sla_pertel() 3rd argument (date1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable date0 */
    f2py_success = double_from_pyobj(&date0,date0_capi,"slalib.sla_pertel() 2nd argument (date0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable orbi1 */
  /* Processing variable orbi0 */
    f2py_success = double_from_pyobj(&orbi0,orbi0_capi,"slalib.sla_pertel() 5th argument (orbi0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable aorq0 */
    f2py_success = double_from_pyobj(&aorq0,aorq0_capi,"slalib.sla_pertel() 8th argument (aorq0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable aorq1 */
  /* Processing variable jstat */
  /* Processing variable jform */
    f2py_success = int_from_pyobj(&jform,jform_capi,"slalib.sla_pertel() 1st argument (jform) can't be converted to int");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&jform,&date0,&date1,&epoch0,&orbi0,&anode0,&perih0,&aorq0,&e0,&am0,&epoch1,&orbi1,&anode1,&perih1,&aorq1,&e1,&am1,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dddddddi",epoch1,orbi1,anode1,perih1,aorq1,e1,am1,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of jform*/
  /* End of cleaning variable jform */
  /* End of cleaning variable jstat */
  /* End of cleaning variable aorq1 */
  } /*if (f2py_success) of aorq0*/
  /* End of cleaning variable aorq0 */
  } /*if (f2py_success) of orbi0*/
  /* End of cleaning variable orbi0 */
  /* End of cleaning variable orbi1 */
  } /*if (f2py_success) of date0*/
  /* End of cleaning variable date0 */
  } /*if (f2py_success) of date1*/
  /* End of cleaning variable date1 */
  } /*if (f2py_success) of e0*/
  /* End of cleaning variable e0 */
  /* End of cleaning variable e1 */
  } /*if (f2py_success) of am0*/
  /* End of cleaning variable am0 */
  /* End of cleaning variable am1 */
  } /*if (f2py_success) of epoch0*/
  /* End of cleaning variable epoch0 */
  /* End of cleaning variable epoch1 */
  /* End of cleaning variable perih1 */
  } /*if (f2py_success) of perih0*/
  /* End of cleaning variable perih0 */
  } /*if (f2py_success) of anode0*/
  /* End of cleaning variable anode0 */
  /* End of cleaning variable anode1 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_pertel *****************************/

/********************************* sla_pertue *********************************/
static char doc_f2py_rout_slalib_sla_pertue[] = "\
Function signature:\n\
  u,jstat = sla_pertue(date,u)\n\
Required arguments:\n"
"  date : input float\n"
"  u : input rank-1 array('d') with bounds (13)\n"
"Return objects:\n"
"  u : rank-1 array('d') with bounds (13)\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_pertue,SLA_PERTUE)(double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_pertue(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double *u = NULL;
  npy_intp u_Dims[1] = {-1};
  const int u_Rank = 1;
  PyArrayObject *capi_u_tmp = NULL;
  int capi_u_intent = 0;
  PyObject *u_capi = Py_None;
  int jstat = 0;
  static char *capi_kwlist[] = {"date","u",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_pertue",\
    capi_kwlist,&date_capi,&u_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_pertue() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable jstat */
  /* Processing variable u */
  u_Dims[0]=13;
  capi_u_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_u_tmp = array_from_pyobj(PyArray_DOUBLE,u_Dims,u_Rank,capi_u_intent,u_capi);
  if (capi_u_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `u' of slalib.sla_pertue to C/Fortran array" );
  } else {
    u = (double *)(capi_u_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,u,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Ni",capi_u_tmp,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_u_tmp == NULL) ... else of u*/
  /* End of cleaning variable u */
  /* End of cleaning variable jstat */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_pertue *****************************/

/********************************* sla_planel *********************************/
static char doc_f2py_rout_slalib_sla_planel[] = "\
Function signature:\n\
  pv,jstat = sla_planel(date,jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm)\n\
Required arguments:\n"
"  date : input float\n"
"  jform : input int\n"
"  epoch : input float\n"
"  orbinc : input float\n"
"  anode : input float\n"
"  perih : input float\n"
"  aorq : input float\n"
"  e : input float\n"
"  aorl : input float\n"
"  dm : input float\n"
"Return objects:\n"
"  pv : rank-1 array('d') with bounds (6)\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_planel,SLA_PLANEL)(double*,int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_planel(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  int jform = 0;
  PyObject *jform_capi = Py_None;
  double epoch = 0;
  PyObject *epoch_capi = Py_None;
  double orbinc = 0;
  PyObject *orbinc_capi = Py_None;
  double anode = 0;
  PyObject *anode_capi = Py_None;
  double perih = 0;
  PyObject *perih_capi = Py_None;
  double aorq = 0;
  PyObject *aorq_capi = Py_None;
  double e = 0;
  PyObject *e_capi = Py_None;
  double aorl = 0;
  PyObject *aorl_capi = Py_None;
  double dm = 0;
  PyObject *dm_capi = Py_None;
  double *pv = NULL;
  npy_intp pv_Dims[1] = {-1};
  const int pv_Rank = 1;
  PyArrayObject *capi_pv_tmp = NULL;
  int capi_pv_intent = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"date","jform","epoch","orbinc","anode","perih","aorq","e","aorl","dm",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOOOO|:slalib.sla_planel",\
    capi_kwlist,&date_capi,&jform_capi,&epoch_capi,&orbinc_capi,&anode_capi,&perih_capi,&aorq_capi,&e_capi,&aorl_capi,&dm_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dm */
    f2py_success = double_from_pyobj(&dm,dm_capi,"slalib.sla_planel() 10th argument (dm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable e */
    f2py_success = double_from_pyobj(&e,e_capi,"slalib.sla_planel() 8th argument (e) can't be converted to double");
  if (f2py_success) {
  /* Processing variable perih */
    f2py_success = double_from_pyobj(&perih,perih_capi,"slalib.sla_planel() 6th argument (perih) can't be converted to double");
  if (f2py_success) {
  /* Processing variable aorl */
    f2py_success = double_from_pyobj(&aorl,aorl_capi,"slalib.sla_planel() 9th argument (aorl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable epoch */
    f2py_success = double_from_pyobj(&epoch,epoch_capi,"slalib.sla_planel() 3rd argument (epoch) can't be converted to double");
  if (f2py_success) {
  /* Processing variable orbinc */
    f2py_success = double_from_pyobj(&orbinc,orbinc_capi,"slalib.sla_planel() 4th argument (orbinc) can't be converted to double");
  if (f2py_success) {
  /* Processing variable anode */
    f2py_success = double_from_pyobj(&anode,anode_capi,"slalib.sla_planel() 5th argument (anode) can't be converted to double");
  if (f2py_success) {
  /* Processing variable aorq */
    f2py_success = double_from_pyobj(&aorq,aorq_capi,"slalib.sla_planel() 7th argument (aorq) can't be converted to double");
  if (f2py_success) {
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_planel() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable pv */
  pv_Dims[0]=6;
  capi_pv_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_pv_tmp = array_from_pyobj(PyArray_DOUBLE,pv_Dims,pv_Rank,capi_pv_intent,Py_None);
  if (capi_pv_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `pv' of slalib.sla_planel to C/Fortran array" );
  } else {
    pv = (double *)(capi_pv_tmp->data);

  /* Processing variable jform */
    f2py_success = int_from_pyobj(&jform,jform_capi,"slalib.sla_planel() 2nd argument (jform) can't be converted to int");
  if (f2py_success) {
  /* Processing variable jstat */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,&jform,&epoch,&orbinc,&anode,&perih,&aorq,&e,&aorl,&dm,pv,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Ni",capi_pv_tmp,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable jstat */
  } /*if (f2py_success) of jform*/
  /* End of cleaning variable jform */
  }  /*if (capi_pv_tmp == NULL) ... else of pv*/
  /* End of cleaning variable pv */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
  } /*if (f2py_success) of aorq*/
  /* End of cleaning variable aorq */
  } /*if (f2py_success) of anode*/
  /* End of cleaning variable anode */
  } /*if (f2py_success) of orbinc*/
  /* End of cleaning variable orbinc */
  } /*if (f2py_success) of epoch*/
  /* End of cleaning variable epoch */
  } /*if (f2py_success) of aorl*/
  /* End of cleaning variable aorl */
  } /*if (f2py_success) of perih*/
  /* End of cleaning variable perih */
  } /*if (f2py_success) of e*/
  /* End of cleaning variable e */
  } /*if (f2py_success) of dm*/
  /* End of cleaning variable dm */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_planel *****************************/

/********************************* sla_planet *********************************/
static char doc_f2py_rout_slalib_sla_planet[] = "\
Function signature:\n\
  pv,jstat = sla_planet(date,np)\n\
Required arguments:\n"
"  date : input float\n"
"  np : input int\n"
"Return objects:\n"
"  pv : rank-1 array('d') with bounds (6)\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_planet,SLA_PLANET)(double*,int*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_planet(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,int*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  int np = 0;
  PyObject *np_capi = Py_None;
  double *pv = NULL;
  npy_intp pv_Dims[1] = {-1};
  const int pv_Rank = 1;
  PyArrayObject *capi_pv_tmp = NULL;
  int capi_pv_intent = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"date","np",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_planet",\
    capi_kwlist,&date_capi,&np_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_planet() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable np */
    f2py_success = int_from_pyobj(&np,np_capi,"slalib.sla_planet() 2nd argument (np) can't be converted to int");
  if (f2py_success) {
  /* Processing variable pv */
  pv_Dims[0]=6;
  capi_pv_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_pv_tmp = array_from_pyobj(PyArray_DOUBLE,pv_Dims,pv_Rank,capi_pv_intent,Py_None);
  if (capi_pv_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `pv' of slalib.sla_planet to C/Fortran array" );
  } else {
    pv = (double *)(capi_pv_tmp->data);

  /* Processing variable jstat */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,&np,pv,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Ni",capi_pv_tmp,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable jstat */
  }  /*if (capi_pv_tmp == NULL) ... else of pv*/
  /* End of cleaning variable pv */
  } /*if (f2py_success) of np*/
  /* End of cleaning variable np */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_planet *****************************/

/********************************* sla_plante *********************************/
static char doc_f2py_rout_slalib_sla_plante[] = "\
Function signature:\n\
  ra,dec,r,jstat = sla_plante(date,elong,phi,jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm)\n\
Required arguments:\n"
"  date : input float\n"
"  elong : input float\n"
"  phi : input float\n"
"  jform : input int\n"
"  epoch : input float\n"
"  orbinc : input float\n"
"  anode : input float\n"
"  perih : input float\n"
"  aorq : input float\n"
"  e : input float\n"
"  aorl : input float\n"
"  dm : input float\n"
"Return objects:\n"
"  ra : float\n"
"  dec : float\n"
"  r : float\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_plante,SLA_PLANTE)(double*,double*,double*,int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_plante(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,int*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double elong = 0;
  PyObject *elong_capi = Py_None;
  double phi = 0;
  PyObject *phi_capi = Py_None;
  int jform = 0;
  PyObject *jform_capi = Py_None;
  double epoch = 0;
  PyObject *epoch_capi = Py_None;
  double orbinc = 0;
  PyObject *orbinc_capi = Py_None;
  double anode = 0;
  PyObject *anode_capi = Py_None;
  double perih = 0;
  PyObject *perih_capi = Py_None;
  double aorq = 0;
  PyObject *aorq_capi = Py_None;
  double e = 0;
  PyObject *e_capi = Py_None;
  double aorl = 0;
  PyObject *aorl_capi = Py_None;
  double dm = 0;
  PyObject *dm_capi = Py_None;
  double ra = 0;
  double dec = 0;
  double r = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"date","elong","phi","jform","epoch","orbinc","anode","perih","aorq","e","aorl","dm",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOOOOOO|:slalib.sla_plante",\
    capi_kwlist,&date_capi,&elong_capi,&phi_capi,&jform_capi,&epoch_capi,&orbinc_capi,&anode_capi,&perih_capi,&aorq_capi,&e_capi,&aorl_capi,&dm_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable orbinc */
    f2py_success = double_from_pyobj(&orbinc,orbinc_capi,"slalib.sla_plante() 6th argument (orbinc) can't be converted to double");
  if (f2py_success) {
  /* Processing variable phi */
    f2py_success = double_from_pyobj(&phi,phi_capi,"slalib.sla_plante() 3rd argument (phi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dm */
    f2py_success = double_from_pyobj(&dm,dm_capi,"slalib.sla_plante() 12nd argument (dm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable anode */
    f2py_success = double_from_pyobj(&anode,anode_capi,"slalib.sla_plante() 7th argument (anode) can't be converted to double");
  if (f2py_success) {
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_plante() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable e */
    f2py_success = double_from_pyobj(&e,e_capi,"slalib.sla_plante() 10th argument (e) can't be converted to double");
  if (f2py_success) {
  /* Processing variable perih */
    f2py_success = double_from_pyobj(&perih,perih_capi,"slalib.sla_plante() 8th argument (perih) can't be converted to double");
  if (f2py_success) {
  /* Processing variable aorl */
    f2py_success = double_from_pyobj(&aorl,aorl_capi,"slalib.sla_plante() 11st argument (aorl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable epoch */
    f2py_success = double_from_pyobj(&epoch,epoch_capi,"slalib.sla_plante() 5th argument (epoch) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r */
  /* Processing variable ra */
  /* Processing variable elong */
    f2py_success = double_from_pyobj(&elong,elong_capi,"slalib.sla_plante() 2nd argument (elong) can't be converted to double");
  if (f2py_success) {
  /* Processing variable aorq */
    f2py_success = double_from_pyobj(&aorq,aorq_capi,"slalib.sla_plante() 9th argument (aorq) can't be converted to double");
  if (f2py_success) {
  /* Processing variable jstat */
  /* Processing variable dec */
  /* Processing variable jform */
    f2py_success = int_from_pyobj(&jform,jform_capi,"slalib.sla_plante() 4th argument (jform) can't be converted to int");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,&elong,&phi,&jform,&epoch,&orbinc,&anode,&perih,&aorq,&e,&aorl,&dm,&ra,&dec,&r,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dddi",ra,dec,r,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of jform*/
  /* End of cleaning variable jform */
  /* End of cleaning variable dec */
  /* End of cleaning variable jstat */
  } /*if (f2py_success) of aorq*/
  /* End of cleaning variable aorq */
  } /*if (f2py_success) of elong*/
  /* End of cleaning variable elong */
  /* End of cleaning variable ra */
  /* End of cleaning variable r */
  } /*if (f2py_success) of epoch*/
  /* End of cleaning variable epoch */
  } /*if (f2py_success) of aorl*/
  /* End of cleaning variable aorl */
  } /*if (f2py_success) of perih*/
  /* End of cleaning variable perih */
  } /*if (f2py_success) of e*/
  /* End of cleaning variable e */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
  } /*if (f2py_success) of anode*/
  /* End of cleaning variable anode */
  } /*if (f2py_success) of dm*/
  /* End of cleaning variable dm */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
  } /*if (f2py_success) of orbinc*/
  /* End of cleaning variable orbinc */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_plante *****************************/

/********************************* sla_plantu *********************************/
static char doc_f2py_rout_slalib_sla_plantu[] = "\
Function signature:\n\
  ra,dec,r,jstat = sla_plantu(date,elong,phi,u)\n\
Required arguments:\n"
"  date : input float\n"
"  elong : input float\n"
"  phi : input float\n"
"  u : input rank-1 array('d') with bounds (13)\n"
"Return objects:\n"
"  ra : float\n"
"  dec : float\n"
"  r : float\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_plantu,SLA_PLANTU)(double*,double*,double*,double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_plantu(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double elong = 0;
  PyObject *elong_capi = Py_None;
  double phi = 0;
  PyObject *phi_capi = Py_None;
  double *u = NULL;
  npy_intp u_Dims[1] = {-1};
  const int u_Rank = 1;
  PyArrayObject *capi_u_tmp = NULL;
  int capi_u_intent = 0;
  PyObject *u_capi = Py_None;
  double ra = 0;
  double dec = 0;
  double r = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"date","elong","phi","u",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_plantu",\
    capi_kwlist,&date_capi,&elong_capi,&phi_capi,&u_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable phi */
    f2py_success = double_from_pyobj(&phi,phi_capi,"slalib.sla_plantu() 3rd argument (phi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r */
  /* Processing variable u */
  u_Dims[0]=13;
  capi_u_intent |= F2PY_INTENT_IN;
  capi_u_tmp = array_from_pyobj(PyArray_DOUBLE,u_Dims,u_Rank,capi_u_intent,u_capi);
  if (capi_u_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 4th argument `u' of slalib.sla_plantu to C/Fortran array" );
  } else {
    u = (double *)(capi_u_tmp->data);

  /* Processing variable ra */
  /* Processing variable elong */
    f2py_success = double_from_pyobj(&elong,elong_capi,"slalib.sla_plantu() 2nd argument (elong) can't be converted to double");
  if (f2py_success) {
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_plantu() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable jstat */
  /* Processing variable dec */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,&elong,&phi,u,&ra,&dec,&r,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dddi",ra,dec,r,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dec */
  /* End of cleaning variable jstat */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
  } /*if (f2py_success) of elong*/
  /* End of cleaning variable elong */
  /* End of cleaning variable ra */
  if((PyObject *)capi_u_tmp!=u_capi) {
    Py_XDECREF(capi_u_tmp); }
  }  /*if (capi_u_tmp == NULL) ... else of u*/
  /* End of cleaning variable u */
  /* End of cleaning variable r */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_plantu *****************************/

/*********************************** sla_pm ***********************************/
static char doc_f2py_rout_slalib_sla_pm[] = "\
Function signature:\n\
  r1,d1 = sla_pm(r0,d0,pr,pd,px,rv,ep0,ep1)\n\
Required arguments:\n"
"  r0 : input float\n"
"  d0 : input float\n"
"  pr : input float\n"
"  pd : input float\n"
"  px : input float\n"
"  rv : input float\n"
"  ep0 : input float\n"
"  ep1 : input float\n"
"Return objects:\n"
"  r1 : float\n"
"  d1 : float";
/* extern void F_FUNC_US(sla_pm,SLA_PM)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_pm(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double r0 = 0;
  PyObject *r0_capi = Py_None;
  double d0 = 0;
  PyObject *d0_capi = Py_None;
  double pr = 0;
  PyObject *pr_capi = Py_None;
  double pd = 0;
  PyObject *pd_capi = Py_None;
  double px = 0;
  PyObject *px_capi = Py_None;
  double rv = 0;
  PyObject *rv_capi = Py_None;
  double ep0 = 0;
  PyObject *ep0_capi = Py_None;
  double ep1 = 0;
  PyObject *ep1_capi = Py_None;
  double r1 = 0;
  double d1 = 0;
  static char *capi_kwlist[] = {"r0","d0","pr","pd","px","rv","ep0","ep1",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOO|:slalib.sla_pm",\
    capi_kwlist,&r0_capi,&d0_capi,&pr_capi,&pd_capi,&px_capi,&rv_capi,&ep0_capi,&ep1_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable pr */
    f2py_success = double_from_pyobj(&pr,pr_capi,"slalib.sla_pm() 3rd argument (pr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rv */
    f2py_success = double_from_pyobj(&rv,rv_capi,"slalib.sla_pm() 6th argument (rv) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r0 */
    f2py_success = double_from_pyobj(&r0,r0_capi,"slalib.sla_pm() 1st argument (r0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable r1 */
  /* Processing variable px */
    f2py_success = double_from_pyobj(&px,px_capi,"slalib.sla_pm() 5th argument (px) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ep0 */
    f2py_success = double_from_pyobj(&ep0,ep0_capi,"slalib.sla_pm() 7th argument (ep0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ep1 */
    f2py_success = double_from_pyobj(&ep1,ep1_capi,"slalib.sla_pm() 8th argument (ep1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable pd */
    f2py_success = double_from_pyobj(&pd,pd_capi,"slalib.sla_pm() 4th argument (pd) can't be converted to double");
  if (f2py_success) {
  /* Processing variable d0 */
    f2py_success = double_from_pyobj(&d0,d0_capi,"slalib.sla_pm() 2nd argument (d0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable d1 */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&r0,&d0,&pr,&pd,&px,&rv,&ep0,&ep1,&r1,&d1);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",r1,d1);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable d1 */
  } /*if (f2py_success) of d0*/
  /* End of cleaning variable d0 */
  } /*if (f2py_success) of pd*/
  /* End of cleaning variable pd */
  } /*if (f2py_success) of ep1*/
  /* End of cleaning variable ep1 */
  } /*if (f2py_success) of ep0*/
  /* End of cleaning variable ep0 */
  } /*if (f2py_success) of px*/
  /* End of cleaning variable px */
  /* End of cleaning variable r1 */
  } /*if (f2py_success) of r0*/
  /* End of cleaning variable r0 */
  } /*if (f2py_success) of rv*/
  /* End of cleaning variable rv */
  } /*if (f2py_success) of pr*/
  /* End of cleaning variable pr */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_pm *******************************/

/********************************* sla_polmo *********************************/
static char doc_f2py_rout_slalib_sla_polmo[] = "\
Function signature:\n\
  elong,phi,daz = sla_polmo(elongm,phim,xp,yp)\n\
Required arguments:\n"
"  elongm : input float\n"
"  phim : input float\n"
"  xp : input float\n"
"  yp : input float\n"
"Return objects:\n"
"  elong : float\n"
"  phi : float\n"
"  daz : float";
/* extern void F_FUNC_US(sla_polmo,SLA_POLMO)(double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_polmo(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double elongm = 0;
  PyObject *elongm_capi = Py_None;
  double phim = 0;
  PyObject *phim_capi = Py_None;
  double xp = 0;
  PyObject *xp_capi = Py_None;
  double yp = 0;
  PyObject *yp_capi = Py_None;
  double elong = 0;
  double phi = 0;
  double daz = 0;
  static char *capi_kwlist[] = {"elongm","phim","xp","yp",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_polmo",\
    capi_kwlist,&elongm_capi,&phim_capi,&xp_capi,&yp_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable phi */
  /* Processing variable elong */
  /* Processing variable xp */
    f2py_success = double_from_pyobj(&xp,xp_capi,"slalib.sla_polmo() 3rd argument (xp) can't be converted to double");
  if (f2py_success) {
  /* Processing variable yp */
    f2py_success = double_from_pyobj(&yp,yp_capi,"slalib.sla_polmo() 4th argument (yp) can't be converted to double");
  if (f2py_success) {
  /* Processing variable phim */
    f2py_success = double_from_pyobj(&phim,phim_capi,"slalib.sla_polmo() 2nd argument (phim) can't be converted to double");
  if (f2py_success) {
  /* Processing variable elongm */
    f2py_success = double_from_pyobj(&elongm,elongm_capi,"slalib.sla_polmo() 1st argument (elongm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable daz */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&elongm,&phim,&xp,&yp,&elong,&phi,&daz);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ddd",elong,phi,daz);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable daz */
  } /*if (f2py_success) of elongm*/
  /* End of cleaning variable elongm */
  } /*if (f2py_success) of phim*/
  /* End of cleaning variable phim */
  } /*if (f2py_success) of yp*/
  /* End of cleaning variable yp */
  } /*if (f2py_success) of xp*/
  /* End of cleaning variable xp */
  /* End of cleaning variable elong */
  /* End of cleaning variable phi */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_polmo ******************************/

/********************************* sla_prebn *********************************/
static char doc_f2py_rout_slalib_sla_prebn[] = "\
Function signature:\n\
  rmatp = sla_prebn(bep0,bep1)\n\
Required arguments:\n"
"  bep0 : input float\n"
"  bep1 : input float\n"
"Return objects:\n"
"  rmatp : rank-2 array('d') with bounds (3,3)";
/* extern void F_FUNC_US(sla_prebn,SLA_PREBN)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_prebn(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double bep0 = 0;
  PyObject *bep0_capi = Py_None;
  double bep1 = 0;
  PyObject *bep1_capi = Py_None;
  double *rmatp = NULL;
  npy_intp rmatp_Dims[2] = {-1, -1};
  const int rmatp_Rank = 2;
  PyArrayObject *capi_rmatp_tmp = NULL;
  int capi_rmatp_intent = 0;
  static char *capi_kwlist[] = {"bep0","bep1",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_prebn",\
    capi_kwlist,&bep0_capi,&bep1_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rmatp */
  rmatp_Dims[0]=3,rmatp_Dims[1]=3;
  capi_rmatp_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_rmatp_tmp = array_from_pyobj(PyArray_DOUBLE,rmatp_Dims,rmatp_Rank,capi_rmatp_intent,Py_None);
  if (capi_rmatp_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `rmatp' of slalib.sla_prebn to C/Fortran array" );
  } else {
    rmatp = (double *)(capi_rmatp_tmp->data);

  /* Processing variable bep1 */
    f2py_success = double_from_pyobj(&bep1,bep1_capi,"slalib.sla_prebn() 2nd argument (bep1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable bep0 */
    f2py_success = double_from_pyobj(&bep0,bep0_capi,"slalib.sla_prebn() 1st argument (bep0) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&bep0,&bep1,rmatp);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_rmatp_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of bep0*/
  /* End of cleaning variable bep0 */
  } /*if (f2py_success) of bep1*/
  /* End of cleaning variable bep1 */
  }  /*if (capi_rmatp_tmp == NULL) ... else of rmatp*/
  /* End of cleaning variable rmatp */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_prebn ******************************/

/********************************* sla_preces *********************************/
static char doc_f2py_rout_slalib_sla_preces[] = "\
Function signature:\n\
  ra,dc = sla_preces(system,ep0,ep1,ra,dc)\n\
Required arguments:\n"
"  system : input string(len=-1)\n"
"  ep0 : input float\n"
"  ep1 : input float\n"
"  ra : input float\n"
"  dc : input float\n"
"Return objects:\n"
"  ra : float\n"
"  dc : float";
/* extern void F_FUNC_US(sla_preces,SLA_PRECES)(string,double*,double*,double*,double*,size_t); */
static PyObject *f2py_rout_slalib_sla_preces(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(string,double*,double*,double*,double*,size_t)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  string system = NULL;
  int slen(system);
  PyObject *system_capi = Py_None;
  double ep0 = 0;
  PyObject *ep0_capi = Py_None;
  double ep1 = 0;
  PyObject *ep1_capi = Py_None;
  double ra = 0;
  PyObject *ra_capi = Py_None;
  double dc = 0;
  PyObject *dc_capi = Py_None;
  static char *capi_kwlist[] = {"system","ep0","ep1","ra","dc",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOO|:slalib.sla_preces",\
    capi_kwlist,&system_capi,&ep0_capi,&ep1_capi,&ra_capi,&dc_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable system */
  slen(system) = -1;
  f2py_success = string_from_pyobj(&system,&slen(system),"",system_capi,"string_from_pyobj failed in converting 1st argument `system' of slalib.sla_preces to C string");
  if (f2py_success) {
  /* Processing variable ep1 */
    f2py_success = double_from_pyobj(&ep1,ep1_capi,"slalib.sla_preces() 3rd argument (ep1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dc */
    f2py_success = double_from_pyobj(&dc,dc_capi,"slalib.sla_preces() 5th argument (dc) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ep0 */
    f2py_success = double_from_pyobj(&ep0,ep0_capi,"slalib.sla_preces() 2nd argument (ep0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ra */
    f2py_success = double_from_pyobj(&ra,ra_capi,"slalib.sla_preces() 4th argument (ra) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(system,&ep0,&ep1,&ra,&dc,slen(system));
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",ra,dc);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of ra*/
  /* End of cleaning variable ra */
  } /*if (f2py_success) of ep0*/
  /* End of cleaning variable ep0 */
  } /*if (f2py_success) of dc*/
  /* End of cleaning variable dc */
  } /*if (f2py_success) of ep1*/
  /* End of cleaning variable ep1 */
    STRINGFREE(system);
  }  /*if (f2py_success) of system*/
  /* End of cleaning variable system */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_preces *****************************/

/********************************** sla_prec **********************************/
static char doc_f2py_rout_slalib_sla_prec[] = "\
Function signature:\n\
  rmatp = sla_prec(ep0,ep1)\n\
Required arguments:\n"
"  ep0 : input float\n"
"  ep1 : input float\n"
"Return objects:\n"
"  rmatp : rank-2 array('d') with bounds (3,3)";
/* extern void F_FUNC_US(sla_prec,SLA_PREC)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_prec(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double ep0 = 0;
  PyObject *ep0_capi = Py_None;
  double ep1 = 0;
  PyObject *ep1_capi = Py_None;
  double *rmatp = NULL;
  npy_intp rmatp_Dims[2] = {-1, -1};
  const int rmatp_Rank = 2;
  PyArrayObject *capi_rmatp_tmp = NULL;
  int capi_rmatp_intent = 0;
  static char *capi_kwlist[] = {"ep0","ep1",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_prec",\
    capi_kwlist,&ep0_capi,&ep1_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rmatp */
  rmatp_Dims[0]=3,rmatp_Dims[1]=3;
  capi_rmatp_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_rmatp_tmp = array_from_pyobj(PyArray_DOUBLE,rmatp_Dims,rmatp_Rank,capi_rmatp_intent,Py_None);
  if (capi_rmatp_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `rmatp' of slalib.sla_prec to C/Fortran array" );
  } else {
    rmatp = (double *)(capi_rmatp_tmp->data);

  /* Processing variable ep0 */
    f2py_success = double_from_pyobj(&ep0,ep0_capi,"slalib.sla_prec() 1st argument (ep0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ep1 */
    f2py_success = double_from_pyobj(&ep1,ep1_capi,"slalib.sla_prec() 2nd argument (ep1) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ep0,&ep1,rmatp);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_rmatp_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of ep1*/
  /* End of cleaning variable ep1 */
  } /*if (f2py_success) of ep0*/
  /* End of cleaning variable ep0 */
  }  /*if (capi_rmatp_tmp == NULL) ... else of rmatp*/
  /* End of cleaning variable rmatp */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_prec ******************************/

/********************************* sla_precl *********************************/
static char doc_f2py_rout_slalib_sla_precl[] = "\
Function signature:\n\
  rmatp = sla_precl(ep0,ep1)\n\
Required arguments:\n"
"  ep0 : input float\n"
"  ep1 : input float\n"
"Return objects:\n"
"  rmatp : rank-2 array('d') with bounds (3,3)";
/* extern void F_FUNC_US(sla_precl,SLA_PRECL)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_precl(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double ep0 = 0;
  PyObject *ep0_capi = Py_None;
  double ep1 = 0;
  PyObject *ep1_capi = Py_None;
  double *rmatp = NULL;
  npy_intp rmatp_Dims[2] = {-1, -1};
  const int rmatp_Rank = 2;
  PyArrayObject *capi_rmatp_tmp = NULL;
  int capi_rmatp_intent = 0;
  static char *capi_kwlist[] = {"ep0","ep1",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_precl",\
    capi_kwlist,&ep0_capi,&ep1_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rmatp */
  rmatp_Dims[0]=3,rmatp_Dims[1]=3;
  capi_rmatp_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_rmatp_tmp = array_from_pyobj(PyArray_DOUBLE,rmatp_Dims,rmatp_Rank,capi_rmatp_intent,Py_None);
  if (capi_rmatp_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `rmatp' of slalib.sla_precl to C/Fortran array" );
  } else {
    rmatp = (double *)(capi_rmatp_tmp->data);

  /* Processing variable ep0 */
    f2py_success = double_from_pyobj(&ep0,ep0_capi,"slalib.sla_precl() 1st argument (ep0) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ep1 */
    f2py_success = double_from_pyobj(&ep1,ep1_capi,"slalib.sla_precl() 2nd argument (ep1) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ep0,&ep1,rmatp);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_rmatp_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of ep1*/
  /* End of cleaning variable ep1 */
  } /*if (f2py_success) of ep0*/
  /* End of cleaning variable ep0 */
  }  /*if (capi_rmatp_tmp == NULL) ... else of rmatp*/
  /* End of cleaning variable rmatp */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_precl ******************************/

/********************************* sla_prenut *********************************/
static char doc_f2py_rout_slalib_sla_prenut[] = "\
Function signature:\n\
  rmatpn = sla_prenut(epoch,date)\n\
Required arguments:\n"
"  epoch : input float\n"
"  date : input float\n"
"Return objects:\n"
"  rmatpn : rank-2 array('d') with bounds (3,3)";
/* extern void F_FUNC_US(sla_prenut,SLA_PRENUT)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_prenut(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double epoch = 0;
  PyObject *epoch_capi = Py_None;
  double date = 0;
  PyObject *date_capi = Py_None;
  double *rmatpn = NULL;
  npy_intp rmatpn_Dims[2] = {-1, -1};
  const int rmatpn_Rank = 2;
  PyArrayObject *capi_rmatpn_tmp = NULL;
  int capi_rmatpn_intent = 0;
  static char *capi_kwlist[] = {"epoch","date",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_prenut",\
    capi_kwlist,&epoch_capi,&date_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_prenut() 2nd argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable epoch */
    f2py_success = double_from_pyobj(&epoch,epoch_capi,"slalib.sla_prenut() 1st argument (epoch) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rmatpn */
  rmatpn_Dims[0]=3,rmatpn_Dims[1]=3;
  capi_rmatpn_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_rmatpn_tmp = array_from_pyobj(PyArray_DOUBLE,rmatpn_Dims,rmatpn_Rank,capi_rmatpn_intent,Py_None);
  if (capi_rmatpn_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `rmatpn' of slalib.sla_prenut to C/Fortran array" );
  } else {
    rmatpn = (double *)(capi_rmatpn_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&epoch,&date,rmatpn);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_rmatpn_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_rmatpn_tmp == NULL) ... else of rmatpn*/
  /* End of cleaning variable rmatpn */
  } /*if (f2py_success) of epoch*/
  /* End of cleaning variable epoch */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_prenut *****************************/

/********************************* sla_pv2el *********************************/
static char doc_f2py_rout_slalib_sla_pv2el[] = "\
Function signature:\n\
  jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm,jstat = sla_pv2el(pv,date,pmass,jformr)\n\
Required arguments:\n"
"  pv : input rank-1 array('d') with bounds (6)\n"
"  date : input float\n"
"  pmass : input float\n"
"  jformr : input int\n"
"Return objects:\n"
"  jform : int\n"
"  epoch : float\n"
"  orbinc : float\n"
"  anode : float\n"
"  perih : float\n"
"  aorq : float\n"
"  e : float\n"
"  aorl : float\n"
"  dm : float\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_pv2el,SLA_PV2EL)(double*,double*,double*,int*,int*,double*,double*,double*,double*,double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_pv2el(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,int*,int*,double*,double*,double*,double*,double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *pv = NULL;
  npy_intp pv_Dims[1] = {-1};
  const int pv_Rank = 1;
  PyArrayObject *capi_pv_tmp = NULL;
  int capi_pv_intent = 0;
  PyObject *pv_capi = Py_None;
  double date = 0;
  PyObject *date_capi = Py_None;
  double pmass = 0;
  PyObject *pmass_capi = Py_None;
  int jformr = 0;
  PyObject *jformr_capi = Py_None;
  int jform = 0;
  double epoch = 0;
  double orbinc = 0;
  double anode = 0;
  double perih = 0;
  double aorq = 0;
  double e = 0;
  double aorl = 0;
  double dm = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"pv","date","pmass","jformr",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_pv2el",\
    capi_kwlist,&pv_capi,&date_capi,&pmass_capi,&jformr_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dm */
  /* Processing variable pv */
  pv_Dims[0]=6;
  capi_pv_intent |= F2PY_INTENT_IN;
  capi_pv_tmp = array_from_pyobj(PyArray_DOUBLE,pv_Dims,pv_Rank,capi_pv_intent,pv_capi);
  if (capi_pv_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `pv' of slalib.sla_pv2el to C/Fortran array" );
  } else {
    pv = (double *)(capi_pv_tmp->data);

  /* Processing variable pmass */
    f2py_success = double_from_pyobj(&pmass,pmass_capi,"slalib.sla_pv2el() 3rd argument (pmass) can't be converted to double");
  if (f2py_success) {
  /* Processing variable perih */
  /* Processing variable aorl */
  /* Processing variable epoch */
  /* Processing variable orbinc */
  /* Processing variable anode */
  /* Processing variable aorq */
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_pv2el() 2nd argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable e */
  /* Processing variable jformr */
    f2py_success = int_from_pyobj(&jformr,jformr_capi,"slalib.sla_pv2el() 4th argument (jformr) can't be converted to int");
  if (f2py_success) {
  /* Processing variable jform */
  /* Processing variable jstat */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(pv,&date,&pmass,&jformr,&jform,&epoch,&orbinc,&anode,&perih,&aorq,&e,&aorl,&dm,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("iddddddddi",jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable jstat */
  /* End of cleaning variable jform */
  } /*if (f2py_success) of jformr*/
  /* End of cleaning variable jformr */
  /* End of cleaning variable e */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
  /* End of cleaning variable aorq */
  /* End of cleaning variable anode */
  /* End of cleaning variable orbinc */
  /* End of cleaning variable epoch */
  /* End of cleaning variable aorl */
  /* End of cleaning variable perih */
  } /*if (f2py_success) of pmass*/
  /* End of cleaning variable pmass */
  if((PyObject *)capi_pv_tmp!=pv_capi) {
    Py_XDECREF(capi_pv_tmp); }
  }  /*if (capi_pv_tmp == NULL) ... else of pv*/
  /* End of cleaning variable pv */
  /* End of cleaning variable dm */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_pv2el ******************************/

/********************************* sla_pv2ue *********************************/
static char doc_f2py_rout_slalib_sla_pv2ue[] = "\
Function signature:\n\
  u,jstat = sla_pv2ue(pv,date,pmass)\n\
Required arguments:\n"
"  pv : input rank-1 array('d') with bounds (6)\n"
"  date : input float\n"
"  pmass : input float\n"
"Return objects:\n"
"  u : rank-1 array('d') with bounds (13)\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_pv2ue,SLA_PV2UE)(double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_pv2ue(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *pv = NULL;
  npy_intp pv_Dims[1] = {-1};
  const int pv_Rank = 1;
  PyArrayObject *capi_pv_tmp = NULL;
  int capi_pv_intent = 0;
  PyObject *pv_capi = Py_None;
  double date = 0;
  PyObject *date_capi = Py_None;
  double pmass = 0;
  PyObject *pmass_capi = Py_None;
  double *u = NULL;
  npy_intp u_Dims[1] = {-1};
  const int u_Rank = 1;
  PyArrayObject *capi_u_tmp = NULL;
  int capi_u_intent = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"pv","date","pmass",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_pv2ue",\
    capi_kwlist,&pv_capi,&date_capi,&pmass_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_pv2ue() 2nd argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable pv */
  pv_Dims[0]=6;
  capi_pv_intent |= F2PY_INTENT_IN;
  capi_pv_tmp = array_from_pyobj(PyArray_DOUBLE,pv_Dims,pv_Rank,capi_pv_intent,pv_capi);
  if (capi_pv_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `pv' of slalib.sla_pv2ue to C/Fortran array" );
  } else {
    pv = (double *)(capi_pv_tmp->data);

  /* Processing variable u */
  u_Dims[0]=13;
  capi_u_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_u_tmp = array_from_pyobj(PyArray_DOUBLE,u_Dims,u_Rank,capi_u_intent,Py_None);
  if (capi_u_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `u' of slalib.sla_pv2ue to C/Fortran array" );
  } else {
    u = (double *)(capi_u_tmp->data);

  /* Processing variable pmass */
    f2py_success = double_from_pyobj(&pmass,pmass_capi,"slalib.sla_pv2ue() 3rd argument (pmass) can't be converted to double");
  if (f2py_success) {
  /* Processing variable jstat */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(pv,&date,&pmass,u,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Ni",capi_u_tmp,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable jstat */
  } /*if (f2py_success) of pmass*/
  /* End of cleaning variable pmass */
  }  /*if (capi_u_tmp == NULL) ... else of u*/
  /* End of cleaning variable u */
  if((PyObject *)capi_pv_tmp!=pv_capi) {
    Py_XDECREF(capi_pv_tmp); }
  }  /*if (capi_pv_tmp == NULL) ... else of pv*/
  /* End of cleaning variable pv */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_pv2ue ******************************/

/********************************* sla_pvobs *********************************/
static char doc_f2py_rout_slalib_sla_pvobs[] = "\
Function signature:\n\
  pv = sla_pvobs(p,h,stl)\n\
Required arguments:\n"
"  p : input float\n"
"  h : input float\n"
"  stl : input float\n"
"Return objects:\n"
"  pv : rank-1 array('d') with bounds (6)";
/* extern void F_FUNC_US(sla_pvobs,SLA_PVOBS)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_pvobs(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double p = 0;
  PyObject *p_capi = Py_None;
  double h = 0;
  PyObject *h_capi = Py_None;
  double stl = 0;
  PyObject *stl_capi = Py_None;
  double *pv = NULL;
  npy_intp pv_Dims[1] = {-1};
  const int pv_Rank = 1;
  PyArrayObject *capi_pv_tmp = NULL;
  int capi_pv_intent = 0;
  static char *capi_kwlist[] = {"p","h","stl",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_pvobs",\
    capi_kwlist,&p_capi,&h_capi,&stl_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable stl */
    f2py_success = double_from_pyobj(&stl,stl_capi,"slalib.sla_pvobs() 3rd argument (stl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable p */
    f2py_success = double_from_pyobj(&p,p_capi,"slalib.sla_pvobs() 1st argument (p) can't be converted to double");
  if (f2py_success) {
  /* Processing variable pv */
  pv_Dims[0]=6;
  capi_pv_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_pv_tmp = array_from_pyobj(PyArray_DOUBLE,pv_Dims,pv_Rank,capi_pv_intent,Py_None);
  if (capi_pv_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `pv' of slalib.sla_pvobs to C/Fortran array" );
  } else {
    pv = (double *)(capi_pv_tmp->data);

  /* Processing variable h */
    f2py_success = double_from_pyobj(&h,h_capi,"slalib.sla_pvobs() 2nd argument (h) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&p,&h,&stl,pv);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_pv_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of h*/
  /* End of cleaning variable h */
  }  /*if (capi_pv_tmp == NULL) ... else of pv*/
  /* End of cleaning variable pv */
  } /*if (f2py_success) of p*/
  /* End of cleaning variable p */
  } /*if (f2py_success) of stl*/
  /* End of cleaning variable stl */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_pvobs ******************************/

/********************************** sla_pxy **********************************/
static char doc_f2py_rout_slalib_sla_pxy[] = "\
Function signature:\n\
  xyp,xrms,yrms,rrms = sla_pxy(xye,xym,coeffs,[np])\n\
Required arguments:\n"
"  xye : input rank-2 array('d') with bounds (2,np)\n"
"  xym : input rank-2 array('d') with bounds (2,np)\n"
"  coeffs : input rank-1 array('d') with bounds (6)\n"
"Optional arguments:\n"
"  np := shape(xye,1) input int\n"
"Return objects:\n"
"  xyp : rank-2 array('d') with bounds (2,np)\n"
"  xrms : float\n"
"  yrms : float\n"
"  rrms : float";
/* extern void F_FUNC_US(sla_pxy,SLA_PXY)(int*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_pxy(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int np = 0;
  PyObject *np_capi = Py_None;
  double *xye = NULL;
  npy_intp xye_Dims[2] = {-1, -1};
  const int xye_Rank = 2;
  PyArrayObject *capi_xye_tmp = NULL;
  int capi_xye_intent = 0;
  PyObject *xye_capi = Py_None;
  double *xym = NULL;
  npy_intp xym_Dims[2] = {-1, -1};
  const int xym_Rank = 2;
  PyArrayObject *capi_xym_tmp = NULL;
  int capi_xym_intent = 0;
  PyObject *xym_capi = Py_None;
  double *coeffs = NULL;
  npy_intp coeffs_Dims[1] = {-1};
  const int coeffs_Rank = 1;
  PyArrayObject *capi_coeffs_tmp = NULL;
  int capi_coeffs_intent = 0;
  PyObject *coeffs_capi = Py_None;
  double *xyp = NULL;
  npy_intp xyp_Dims[2] = {-1, -1};
  const int xyp_Rank = 2;
  PyArrayObject *capi_xyp_tmp = NULL;
  int capi_xyp_intent = 0;
  double xrms = 0;
  double yrms = 0;
  double rrms = 0;
  static char *capi_kwlist[] = {"xye","xym","coeffs","np",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|O:slalib.sla_pxy",\
    capi_kwlist,&xye_capi,&xym_capi,&coeffs_capi,&np_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable yrms */
  /* Processing variable rrms */
  /* Processing variable xye */
  xye_Dims[0]=2;
  capi_xye_intent |= F2PY_INTENT_IN;
  capi_xye_tmp = array_from_pyobj(PyArray_DOUBLE,xye_Dims,xye_Rank,capi_xye_intent,xye_capi);
  if (capi_xye_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `xye' of slalib.sla_pxy to C/Fortran array" );
  } else {
    xye = (double *)(capi_xye_tmp->data);

  /* Processing variable coeffs */
  coeffs_Dims[0]=6;
  capi_coeffs_intent |= F2PY_INTENT_IN;
  capi_coeffs_tmp = array_from_pyobj(PyArray_DOUBLE,coeffs_Dims,coeffs_Rank,capi_coeffs_intent,coeffs_capi);
  if (capi_coeffs_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `coeffs' of slalib.sla_pxy to C/Fortran array" );
  } else {
    coeffs = (double *)(capi_coeffs_tmp->data);

  /* Processing variable xrms */
  /* Processing variable np */
  if (np_capi == Py_None) np = shape(xye,1); else
    f2py_success = int_from_pyobj(&np,np_capi,"slalib.sla_pxy() 1st keyword (np) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(shape(xye,1)==np,"shape(xye,1)==np","1st keyword np","sla_pxy:np=%d",np) {
  /* Processing variable xym */
  xym_Dims[0]=2,xym_Dims[1]=np;
  capi_xym_intent |= F2PY_INTENT_IN;
  capi_xym_tmp = array_from_pyobj(PyArray_DOUBLE,xym_Dims,xym_Rank,capi_xym_intent,xym_capi);
  if (capi_xym_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `xym' of slalib.sla_pxy to C/Fortran array" );
  } else {
    xym = (double *)(capi_xym_tmp->data);

  /* Processing variable xyp */
  xyp_Dims[0]=2,xyp_Dims[1]=np;
  capi_xyp_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_xyp_tmp = array_from_pyobj(PyArray_DOUBLE,xyp_Dims,xyp_Rank,capi_xyp_intent,Py_None);
  if (capi_xyp_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `xyp' of slalib.sla_pxy to C/Fortran array" );
  } else {
    xyp = (double *)(capi_xyp_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&np,xye,xym,coeffs,xyp,&xrms,&yrms,&rrms);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Nddd",capi_xyp_tmp,xrms,yrms,rrms);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_xyp_tmp == NULL) ... else of xyp*/
  /* End of cleaning variable xyp */
  if((PyObject *)capi_xym_tmp!=xym_capi) {
    Py_XDECREF(capi_xym_tmp); }
  }  /*if (capi_xym_tmp == NULL) ... else of xym*/
  /* End of cleaning variable xym */
  } /*CHECKSCALAR(shape(xye,1)==np)*/
  } /*if (f2py_success) of np*/
  /* End of cleaning variable np */
  /* End of cleaning variable xrms */
  if((PyObject *)capi_coeffs_tmp!=coeffs_capi) {
    Py_XDECREF(capi_coeffs_tmp); }
  }  /*if (capi_coeffs_tmp == NULL) ... else of coeffs*/
  /* End of cleaning variable coeffs */
  if((PyObject *)capi_xye_tmp!=xye_capi) {
    Py_XDECREF(capi_xye_tmp); }
  }  /*if (capi_xye_tmp == NULL) ... else of xye*/
  /* End of cleaning variable xye */
  /* End of cleaning variable rrms */
  /* End of cleaning variable yrms */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_pxy *******************************/

/********************************* sla_range *********************************/
static char doc_f2py_rout_slalib_sla_range[] = "\
Function signature:\n\
  sla_range = sla_range(angle)\n\
Required arguments:\n"
"  angle : input float\n"
"Return objects:\n"
"  sla_range : float";
/* extern void F_WRAPPEDFUNC_US(sla_range,SLA_RANGE)(float*,float*); */
static PyObject *f2py_rout_slalib_sla_range(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_range = 0;
  float angle = 0;
  PyObject *angle_capi = Py_None;
  static char *capi_kwlist[] = {"angle",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_range",\
    capi_kwlist,&angle_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable angle */
    f2py_success = float_from_pyobj(&angle,angle_capi,"slalib.sla_range() 1st argument (angle) can't be converted to float");
  if (f2py_success) {
  /* Processing variable sla_range */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_range,&angle);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_range);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_range */
  } /*if (f2py_success) of angle*/
  /* End of cleaning variable angle */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_range ******************************/

/********************************* sla_ranorm *********************************/
static char doc_f2py_rout_slalib_sla_ranorm[] = "\
Function signature:\n\
  sla_ranorm = sla_ranorm(angle)\n\
Required arguments:\n"
"  angle : input float\n"
"Return objects:\n"
"  sla_ranorm : float";
/* extern void F_WRAPPEDFUNC_US(sla_ranorm,SLA_RANORM)(float*,float*); */
static PyObject *f2py_rout_slalib_sla_ranorm(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_ranorm = 0;
  float angle = 0;
  PyObject *angle_capi = Py_None;
  static char *capi_kwlist[] = {"angle",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_ranorm",\
    capi_kwlist,&angle_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable angle */
    f2py_success = float_from_pyobj(&angle,angle_capi,"slalib.sla_ranorm() 1st argument (angle) can't be converted to float");
  if (f2py_success) {
  /* Processing variable sla_ranorm */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_ranorm,&angle);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_ranorm);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_ranorm */
  } /*if (f2py_success) of angle*/
  /* End of cleaning variable angle */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_ranorm *****************************/

/********************************** sla_rcc **********************************/
static char doc_f2py_rout_slalib_sla_rcc[] = "\
Function signature:\n\
  sla_rcc = sla_rcc(tdb,ut1,wl,u,v)\n\
Required arguments:\n"
"  tdb : input float\n"
"  ut1 : input float\n"
"  wl : input float\n"
"  u : input float\n"
"  v : input float\n"
"Return objects:\n"
"  sla_rcc : float";
/* extern void F_WRAPPEDFUNC_US(sla_rcc,SLA_RCC)(double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_rcc(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_rcc = 0;
  double tdb = 0;
  PyObject *tdb_capi = Py_None;
  double ut1 = 0;
  PyObject *ut1_capi = Py_None;
  double wl = 0;
  PyObject *wl_capi = Py_None;
  double u = 0;
  PyObject *u_capi = Py_None;
  double v = 0;
  PyObject *v_capi = Py_None;
  static char *capi_kwlist[] = {"tdb","ut1","wl","u","v",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOO|:slalib.sla_rcc",\
    capi_kwlist,&tdb_capi,&ut1_capi,&wl_capi,&u_capi,&v_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable ut1 */
    f2py_success = double_from_pyobj(&ut1,ut1_capi,"slalib.sla_rcc() 2nd argument (ut1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable u */
    f2py_success = double_from_pyobj(&u,u_capi,"slalib.sla_rcc() 4th argument (u) can't be converted to double");
  if (f2py_success) {
  /* Processing variable v */
    f2py_success = double_from_pyobj(&v,v_capi,"slalib.sla_rcc() 5th argument (v) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_rcc */
  /* Processing variable tdb */
    f2py_success = double_from_pyobj(&tdb,tdb_capi,"slalib.sla_rcc() 1st argument (tdb) can't be converted to double");
  if (f2py_success) {
  /* Processing variable wl */
    f2py_success = double_from_pyobj(&wl,wl_capi,"slalib.sla_rcc() 3rd argument (wl) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_rcc,&tdb,&ut1,&wl,&u,&v);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_rcc);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of wl*/
  /* End of cleaning variable wl */
  } /*if (f2py_success) of tdb*/
  /* End of cleaning variable tdb */
  /* End of cleaning variable sla_rcc */
  } /*if (f2py_success) of v*/
  /* End of cleaning variable v */
  } /*if (f2py_success) of u*/
  /* End of cleaning variable u */
  } /*if (f2py_success) of ut1*/
  /* End of cleaning variable ut1 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_rcc *******************************/

/********************************* sla_rdplan *********************************/
static char doc_f2py_rout_slalib_sla_rdplan[] = "\
Function signature:\n\
  ra,dec,diam = sla_rdplan(date,np,elong,phi)\n\
Required arguments:\n"
"  date : input float\n"
"  np : input int\n"
"  elong : input float\n"
"  phi : input float\n"
"Return objects:\n"
"  ra : float\n"
"  dec : float\n"
"  diam : float";
/* extern void F_FUNC_US(sla_rdplan,SLA_RDPLAN)(double*,int*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_rdplan(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,int*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  int np = 0;
  PyObject *np_capi = Py_None;
  double elong = 0;
  PyObject *elong_capi = Py_None;
  double phi = 0;
  PyObject *phi_capi = Py_None;
  double ra = 0;
  double dec = 0;
  double diam = 0;
  static char *capi_kwlist[] = {"date","np","elong","phi",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_rdplan",\
    capi_kwlist,&date_capi,&np_capi,&elong_capi,&phi_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_rdplan() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable phi */
    f2py_success = double_from_pyobj(&phi,phi_capi,"slalib.sla_rdplan() 4th argument (phi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable diam */
  /* Processing variable ra */
  /* Processing variable elong */
    f2py_success = double_from_pyobj(&elong,elong_capi,"slalib.sla_rdplan() 3rd argument (elong) can't be converted to double");
  if (f2py_success) {
  /* Processing variable np */
    f2py_success = int_from_pyobj(&np,np_capi,"slalib.sla_rdplan() 2nd argument (np) can't be converted to int");
  if (f2py_success) {
  /* Processing variable dec */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,&np,&elong,&phi,&ra,&dec,&diam);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ddd",ra,dec,diam);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dec */
  } /*if (f2py_success) of np*/
  /* End of cleaning variable np */
  } /*if (f2py_success) of elong*/
  /* End of cleaning variable elong */
  /* End of cleaning variable ra */
  /* End of cleaning variable diam */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_rdplan *****************************/

/********************************* sla_refco *********************************/
static char doc_f2py_rout_slalib_sla_refco[] = "\
Function signature:\n\
  refa,refb = sla_refco(hm,tdk,pmb,rh,wl,phi,tlr,eps)\n\
Required arguments:\n"
"  hm : input float\n"
"  tdk : input float\n"
"  pmb : input float\n"
"  rh : input float\n"
"  wl : input float\n"
"  phi : input float\n"
"  tlr : input float\n"
"  eps : input float\n"
"Return objects:\n"
"  refa : float\n"
"  refb : float";
/* extern void F_FUNC_US(sla_refco,SLA_REFCO)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_refco(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double hm = 0;
  PyObject *hm_capi = Py_None;
  double tdk = 0;
  PyObject *tdk_capi = Py_None;
  double pmb = 0;
  PyObject *pmb_capi = Py_None;
  double rh = 0;
  PyObject *rh_capi = Py_None;
  double wl = 0;
  PyObject *wl_capi = Py_None;
  double phi = 0;
  PyObject *phi_capi = Py_None;
  double tlr = 0;
  PyObject *tlr_capi = Py_None;
  double eps = 0;
  PyObject *eps_capi = Py_None;
  double refa = 0;
  double refb = 0;
  static char *capi_kwlist[] = {"hm","tdk","pmb","rh","wl","phi","tlr","eps",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOO|:slalib.sla_refco",\
    capi_kwlist,&hm_capi,&tdk_capi,&pmb_capi,&rh_capi,&wl_capi,&phi_capi,&tlr_capi,&eps_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable tdk */
    f2py_success = double_from_pyobj(&tdk,tdk_capi,"slalib.sla_refco() 2nd argument (tdk) can't be converted to double");
  if (f2py_success) {
  /* Processing variable tlr */
    f2py_success = double_from_pyobj(&tlr,tlr_capi,"slalib.sla_refco() 7th argument (tlr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable phi */
    f2py_success = double_from_pyobj(&phi,phi_capi,"slalib.sla_refco() 6th argument (phi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable wl */
    f2py_success = double_from_pyobj(&wl,wl_capi,"slalib.sla_refco() 5th argument (wl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable eps */
    f2py_success = double_from_pyobj(&eps,eps_capi,"slalib.sla_refco() 8th argument (eps) can't be converted to double");
  if (f2py_success) {
  /* Processing variable pmb */
    f2py_success = double_from_pyobj(&pmb,pmb_capi,"slalib.sla_refco() 3rd argument (pmb) can't be converted to double");
  if (f2py_success) {
  /* Processing variable hm */
    f2py_success = double_from_pyobj(&hm,hm_capi,"slalib.sla_refco() 1st argument (hm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable refa */
  /* Processing variable refb */
  /* Processing variable rh */
    f2py_success = double_from_pyobj(&rh,rh_capi,"slalib.sla_refco() 4th argument (rh) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&hm,&tdk,&pmb,&rh,&wl,&phi,&tlr,&eps,&refa,&refb);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",refa,refb);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of rh*/
  /* End of cleaning variable rh */
  /* End of cleaning variable refb */
  /* End of cleaning variable refa */
  } /*if (f2py_success) of hm*/
  /* End of cleaning variable hm */
  } /*if (f2py_success) of pmb*/
  /* End of cleaning variable pmb */
  } /*if (f2py_success) of eps*/
  /* End of cleaning variable eps */
  } /*if (f2py_success) of wl*/
  /* End of cleaning variable wl */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
  } /*if (f2py_success) of tlr*/
  /* End of cleaning variable tlr */
  } /*if (f2py_success) of tdk*/
  /* End of cleaning variable tdk */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_refco ******************************/

/********************************* sla_refcoq *********************************/
static char doc_f2py_rout_slalib_sla_refcoq[] = "\
Function signature:\n\
  refa,refb = sla_refcoq(tdk,pmb,rh,wl)\n\
Required arguments:\n"
"  tdk : input float\n"
"  pmb : input float\n"
"  rh : input float\n"
"  wl : input float\n"
"Return objects:\n"
"  refa : float\n"
"  refb : float";
/* extern void F_FUNC_US(sla_refcoq,SLA_REFCOQ)(double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_refcoq(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double tdk = 0;
  PyObject *tdk_capi = Py_None;
  double pmb = 0;
  PyObject *pmb_capi = Py_None;
  double rh = 0;
  PyObject *rh_capi = Py_None;
  double wl = 0;
  PyObject *wl_capi = Py_None;
  double refa = 0;
  double refb = 0;
  static char *capi_kwlist[] = {"tdk","pmb","rh","wl",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_refcoq",\
    capi_kwlist,&tdk_capi,&pmb_capi,&rh_capi,&wl_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable tdk */
    f2py_success = double_from_pyobj(&tdk,tdk_capi,"slalib.sla_refcoq() 1st argument (tdk) can't be converted to double");
  if (f2py_success) {
  /* Processing variable refb */
  /* Processing variable pmb */
    f2py_success = double_from_pyobj(&pmb,pmb_capi,"slalib.sla_refcoq() 2nd argument (pmb) can't be converted to double");
  if (f2py_success) {
  /* Processing variable refa */
  /* Processing variable wl */
    f2py_success = double_from_pyobj(&wl,wl_capi,"slalib.sla_refcoq() 4th argument (wl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rh */
    f2py_success = double_from_pyobj(&rh,rh_capi,"slalib.sla_refcoq() 3rd argument (rh) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&tdk,&pmb,&rh,&wl,&refa,&refb);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",refa,refb);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of rh*/
  /* End of cleaning variable rh */
  } /*if (f2py_success) of wl*/
  /* End of cleaning variable wl */
  /* End of cleaning variable refa */
  } /*if (f2py_success) of pmb*/
  /* End of cleaning variable pmb */
  /* End of cleaning variable refb */
  } /*if (f2py_success) of tdk*/
  /* End of cleaning variable tdk */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_refcoq *****************************/

/********************************* sla_refro *********************************/
static char doc_f2py_rout_slalib_sla_refro[] = "\
Function signature:\n\
  ref = sla_refro(zobs,hm,tdk,pmb,rh,wl,phi,tlr,eps)\n\
Required arguments:\n"
"  zobs : input float\n"
"  hm : input float\n"
"  tdk : input float\n"
"  pmb : input float\n"
"  rh : input float\n"
"  wl : input float\n"
"  phi : input float\n"
"  tlr : input float\n"
"  eps : input float\n"
"Return objects:\n"
"  ref : float";
/* extern void F_FUNC_US(sla_refro,SLA_REFRO)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_refro(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double zobs = 0;
  PyObject *zobs_capi = Py_None;
  double hm = 0;
  PyObject *hm_capi = Py_None;
  double tdk = 0;
  PyObject *tdk_capi = Py_None;
  double pmb = 0;
  PyObject *pmb_capi = Py_None;
  double rh = 0;
  PyObject *rh_capi = Py_None;
  double wl = 0;
  PyObject *wl_capi = Py_None;
  double phi = 0;
  PyObject *phi_capi = Py_None;
  double tlr = 0;
  PyObject *tlr_capi = Py_None;
  double eps = 0;
  PyObject *eps_capi = Py_None;
  double ref = 0;
  static char *capi_kwlist[] = {"zobs","hm","tdk","pmb","rh","wl","phi","tlr","eps",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOOOOOOO|:slalib.sla_refro",\
    capi_kwlist,&zobs_capi,&hm_capi,&tdk_capi,&pmb_capi,&rh_capi,&wl_capi,&phi_capi,&tlr_capi,&eps_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable tdk */
    f2py_success = double_from_pyobj(&tdk,tdk_capi,"slalib.sla_refro() 3rd argument (tdk) can't be converted to double");
  if (f2py_success) {
  /* Processing variable tlr */
    f2py_success = double_from_pyobj(&tlr,tlr_capi,"slalib.sla_refro() 8th argument (tlr) can't be converted to double");
  if (f2py_success) {
  /* Processing variable phi */
    f2py_success = double_from_pyobj(&phi,phi_capi,"slalib.sla_refro() 7th argument (phi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rh */
    f2py_success = double_from_pyobj(&rh,rh_capi,"slalib.sla_refro() 5th argument (rh) can't be converted to double");
  if (f2py_success) {
  /* Processing variable wl */
    f2py_success = double_from_pyobj(&wl,wl_capi,"slalib.sla_refro() 6th argument (wl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable eps */
    f2py_success = double_from_pyobj(&eps,eps_capi,"slalib.sla_refro() 9th argument (eps) can't be converted to double");
  if (f2py_success) {
  /* Processing variable zobs */
    f2py_success = double_from_pyobj(&zobs,zobs_capi,"slalib.sla_refro() 1st argument (zobs) can't be converted to double");
  if (f2py_success) {
  /* Processing variable pmb */
    f2py_success = double_from_pyobj(&pmb,pmb_capi,"slalib.sla_refro() 4th argument (pmb) can't be converted to double");
  if (f2py_success) {
  /* Processing variable hm */
    f2py_success = double_from_pyobj(&hm,hm_capi,"slalib.sla_refro() 2nd argument (hm) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ref */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&zobs,&hm,&tdk,&pmb,&rh,&wl,&phi,&tlr,&eps,&ref);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",ref);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable ref */
  } /*if (f2py_success) of hm*/
  /* End of cleaning variable hm */
  } /*if (f2py_success) of pmb*/
  /* End of cleaning variable pmb */
  } /*if (f2py_success) of zobs*/
  /* End of cleaning variable zobs */
  } /*if (f2py_success) of eps*/
  /* End of cleaning variable eps */
  } /*if (f2py_success) of wl*/
  /* End of cleaning variable wl */
  } /*if (f2py_success) of rh*/
  /* End of cleaning variable rh */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
  } /*if (f2py_success) of tlr*/
  /* End of cleaning variable tlr */
  } /*if (f2py_success) of tdk*/
  /* End of cleaning variable tdk */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_refro ******************************/

/********************************** sla_refv **********************************/
static char doc_f2py_rout_slalib_sla_refv[] = "\
Function signature:\n\
  vr = sla_refv(vu,refa,refb)\n\
Required arguments:\n"
"  vu : input rank-1 array('d') with bounds (3)\n"
"  refa : input float\n"
"  refb : input float\n"
"Return objects:\n"
"  vr : rank-1 array('d') with bounds (3)";
/* extern void F_FUNC_US(sla_refv,SLA_REFV)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_refv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *vu = NULL;
  npy_intp vu_Dims[1] = {-1};
  const int vu_Rank = 1;
  PyArrayObject *capi_vu_tmp = NULL;
  int capi_vu_intent = 0;
  PyObject *vu_capi = Py_None;
  double refa = 0;
  PyObject *refa_capi = Py_None;
  double refb = 0;
  PyObject *refb_capi = Py_None;
  double *vr = NULL;
  npy_intp vr_Dims[1] = {-1};
  const int vr_Rank = 1;
  PyArrayObject *capi_vr_tmp = NULL;
  int capi_vr_intent = 0;
  static char *capi_kwlist[] = {"vu","refa","refb",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_refv",\
    capi_kwlist,&vu_capi,&refa_capi,&refb_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable refa */
    f2py_success = double_from_pyobj(&refa,refa_capi,"slalib.sla_refv() 2nd argument (refa) can't be converted to double");
  if (f2py_success) {
  /* Processing variable vr */
  vr_Dims[0]=3;
  capi_vr_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_vr_tmp = array_from_pyobj(PyArray_DOUBLE,vr_Dims,vr_Rank,capi_vr_intent,Py_None);
  if (capi_vr_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `vr' of slalib.sla_refv to C/Fortran array" );
  } else {
    vr = (double *)(capi_vr_tmp->data);

  /* Processing variable refb */
    f2py_success = double_from_pyobj(&refb,refb_capi,"slalib.sla_refv() 3rd argument (refb) can't be converted to double");
  if (f2py_success) {
  /* Processing variable vu */
  vu_Dims[0]=3;
  capi_vu_intent |= F2PY_INTENT_IN;
  capi_vu_tmp = array_from_pyobj(PyArray_DOUBLE,vu_Dims,vu_Rank,capi_vu_intent,vu_capi);
  if (capi_vu_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `vu' of slalib.sla_refv to C/Fortran array" );
  } else {
    vu = (double *)(capi_vu_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(vu,&refa,&refb,vr);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_vr_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_vu_tmp!=vu_capi) {
    Py_XDECREF(capi_vu_tmp); }
  }  /*if (capi_vu_tmp == NULL) ... else of vu*/
  /* End of cleaning variable vu */
  } /*if (f2py_success) of refb*/
  /* End of cleaning variable refb */
  }  /*if (capi_vr_tmp == NULL) ... else of vr*/
  /* End of cleaning variable vr */
  } /*if (f2py_success) of refa*/
  /* End of cleaning variable refa */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_refv ******************************/

/********************************** sla_refz **********************************/
static char doc_f2py_rout_slalib_sla_refz[] = "\
Function signature:\n\
  zr = sla_refz(zu,refa,refb)\n\
Required arguments:\n"
"  zu : input float\n"
"  refa : input float\n"
"  refb : input float\n"
"Return objects:\n"
"  zr : float";
/* extern void F_FUNC_US(sla_refz,SLA_REFZ)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_refz(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double zu = 0;
  PyObject *zu_capi = Py_None;
  double refa = 0;
  PyObject *refa_capi = Py_None;
  double refb = 0;
  PyObject *refb_capi = Py_None;
  double zr = 0;
  static char *capi_kwlist[] = {"zu","refa","refb",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_refz",\
    capi_kwlist,&zu_capi,&refa_capi,&refb_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable refa */
    f2py_success = double_from_pyobj(&refa,refa_capi,"slalib.sla_refz() 2nd argument (refa) can't be converted to double");
  if (f2py_success) {
  /* Processing variable zu */
    f2py_success = double_from_pyobj(&zu,zu_capi,"slalib.sla_refz() 1st argument (zu) can't be converted to double");
  if (f2py_success) {
  /* Processing variable refb */
    f2py_success = double_from_pyobj(&refb,refb_capi,"slalib.sla_refz() 3rd argument (refb) can't be converted to double");
  if (f2py_success) {
  /* Processing variable zr */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&zu,&refa,&refb,&zr);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",zr);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable zr */
  } /*if (f2py_success) of refb*/
  /* End of cleaning variable refb */
  } /*if (f2py_success) of zu*/
  /* End of cleaning variable zu */
  } /*if (f2py_success) of refa*/
  /* End of cleaning variable refa */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_refz ******************************/

/********************************* sla_rverot *********************************/
static char doc_f2py_rout_slalib_sla_rverot[] = "\
Function signature:\n\
  sla_rverot = sla_rverot(phi,ra,da,st)\n\
Required arguments:\n"
"  phi : input float\n"
"  ra : input float\n"
"  da : input float\n"
"  st : input float\n"
"Return objects:\n"
"  sla_rverot : float";
/* extern void F_WRAPPEDFUNC_US(sla_rverot,SLA_RVEROT)(float*,float*,float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_rverot(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_rverot = 0;
  float phi = 0;
  PyObject *phi_capi = Py_None;
  float ra = 0;
  PyObject *ra_capi = Py_None;
  float da = 0;
  PyObject *da_capi = Py_None;
  float st = 0;
  PyObject *st_capi = Py_None;
  static char *capi_kwlist[] = {"phi","ra","da","st",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_rverot",\
    capi_kwlist,&phi_capi,&ra_capi,&da_capi,&st_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable phi */
    f2py_success = float_from_pyobj(&phi,phi_capi,"slalib.sla_rverot() 1st argument (phi) can't be converted to float");
  if (f2py_success) {
  /* Processing variable sla_rverot */
  /* Processing variable da */
    f2py_success = float_from_pyobj(&da,da_capi,"slalib.sla_rverot() 3rd argument (da) can't be converted to float");
  if (f2py_success) {
  /* Processing variable ra */
    f2py_success = float_from_pyobj(&ra,ra_capi,"slalib.sla_rverot() 2nd argument (ra) can't be converted to float");
  if (f2py_success) {
  /* Processing variable st */
    f2py_success = float_from_pyobj(&st,st_capi,"slalib.sla_rverot() 4th argument (st) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_rverot,&phi,&ra,&da,&st);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_rverot);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of st*/
  /* End of cleaning variable st */
  } /*if (f2py_success) of ra*/
  /* End of cleaning variable ra */
  } /*if (f2py_success) of da*/
  /* End of cleaning variable da */
  /* End of cleaning variable sla_rverot */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_rverot *****************************/

/********************************* sla_rvgalc *********************************/
static char doc_f2py_rout_slalib_sla_rvgalc[] = "\
Function signature:\n\
  sla_rvgalc = sla_rvgalc(r2000,d2000)\n\
Required arguments:\n"
"  r2000 : input float\n"
"  d2000 : input float\n"
"Return objects:\n"
"  sla_rvgalc : float";
/* extern void F_WRAPPEDFUNC_US(sla_rvgalc,SLA_RVGALC)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_rvgalc(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_rvgalc = 0;
  float r2000 = 0;
  PyObject *r2000_capi = Py_None;
  float d2000 = 0;
  PyObject *d2000_capi = Py_None;
  static char *capi_kwlist[] = {"r2000","d2000",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_rvgalc",\
    capi_kwlist,&r2000_capi,&d2000_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable sla_rvgalc */
  /* Processing variable r2000 */
    f2py_success = float_from_pyobj(&r2000,r2000_capi,"slalib.sla_rvgalc() 1st argument (r2000) can't be converted to float");
  if (f2py_success) {
  /* Processing variable d2000 */
    f2py_success = float_from_pyobj(&d2000,d2000_capi,"slalib.sla_rvgalc() 2nd argument (d2000) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_rvgalc,&r2000,&d2000);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_rvgalc);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of d2000*/
  /* End of cleaning variable d2000 */
  } /*if (f2py_success) of r2000*/
  /* End of cleaning variable r2000 */
  /* End of cleaning variable sla_rvgalc */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_rvgalc *****************************/

/********************************** sla_rvlg **********************************/
static char doc_f2py_rout_slalib_sla_rvlg[] = "\
Function signature:\n\
  sla_rvlg = sla_rvlg(r2000,d2000)\n\
Required arguments:\n"
"  r2000 : input float\n"
"  d2000 : input float\n"
"Return objects:\n"
"  sla_rvlg : float";
/* extern void F_WRAPPEDFUNC_US(sla_rvlg,SLA_RVLG)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_rvlg(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_rvlg = 0;
  float r2000 = 0;
  PyObject *r2000_capi = Py_None;
  float d2000 = 0;
  PyObject *d2000_capi = Py_None;
  static char *capi_kwlist[] = {"r2000","d2000",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_rvlg",\
    capi_kwlist,&r2000_capi,&d2000_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable r2000 */
    f2py_success = float_from_pyobj(&r2000,r2000_capi,"slalib.sla_rvlg() 1st argument (r2000) can't be converted to float");
  if (f2py_success) {
  /* Processing variable sla_rvlg */
  /* Processing variable d2000 */
    f2py_success = float_from_pyobj(&d2000,d2000_capi,"slalib.sla_rvlg() 2nd argument (d2000) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_rvlg,&r2000,&d2000);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_rvlg);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of d2000*/
  /* End of cleaning variable d2000 */
  /* End of cleaning variable sla_rvlg */
  } /*if (f2py_success) of r2000*/
  /* End of cleaning variable r2000 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_rvlg ******************************/

/********************************* sla_rvlsrd *********************************/
static char doc_f2py_rout_slalib_sla_rvlsrd[] = "\
Function signature:\n\
  sla_rvlsrd = sla_rvlsrd(r2000,d2000)\n\
Required arguments:\n"
"  r2000 : input float\n"
"  d2000 : input float\n"
"Return objects:\n"
"  sla_rvlsrd : float";
/* extern void F_WRAPPEDFUNC_US(sla_rvlsrd,SLA_RVLSRD)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_rvlsrd(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_rvlsrd = 0;
  float r2000 = 0;
  PyObject *r2000_capi = Py_None;
  float d2000 = 0;
  PyObject *d2000_capi = Py_None;
  static char *capi_kwlist[] = {"r2000","d2000",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_rvlsrd",\
    capi_kwlist,&r2000_capi,&d2000_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable r2000 */
    f2py_success = float_from_pyobj(&r2000,r2000_capi,"slalib.sla_rvlsrd() 1st argument (r2000) can't be converted to float");
  if (f2py_success) {
  /* Processing variable sla_rvlsrd */
  /* Processing variable d2000 */
    f2py_success = float_from_pyobj(&d2000,d2000_capi,"slalib.sla_rvlsrd() 2nd argument (d2000) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_rvlsrd,&r2000,&d2000);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_rvlsrd);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of d2000*/
  /* End of cleaning variable d2000 */
  /* End of cleaning variable sla_rvlsrd */
  } /*if (f2py_success) of r2000*/
  /* End of cleaning variable r2000 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_rvlsrd *****************************/

/********************************* sla_rvlsrk *********************************/
static char doc_f2py_rout_slalib_sla_rvlsrk[] = "\
Function signature:\n\
  sla_rvlsrk = sla_rvlsrk(r2000,d2000)\n\
Required arguments:\n"
"  r2000 : input float\n"
"  d2000 : input float\n"
"Return objects:\n"
"  sla_rvlsrk : float";
/* extern void F_WRAPPEDFUNC_US(sla_rvlsrk,SLA_RVLSRK)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_rvlsrk(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_rvlsrk = 0;
  float r2000 = 0;
  PyObject *r2000_capi = Py_None;
  float d2000 = 0;
  PyObject *d2000_capi = Py_None;
  static char *capi_kwlist[] = {"r2000","d2000",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_rvlsrk",\
    capi_kwlist,&r2000_capi,&d2000_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable r2000 */
    f2py_success = float_from_pyobj(&r2000,r2000_capi,"slalib.sla_rvlsrk() 1st argument (r2000) can't be converted to float");
  if (f2py_success) {
  /* Processing variable d2000 */
    f2py_success = float_from_pyobj(&d2000,d2000_capi,"slalib.sla_rvlsrk() 2nd argument (d2000) can't be converted to float");
  if (f2py_success) {
  /* Processing variable sla_rvlsrk */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_rvlsrk,&r2000,&d2000);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_rvlsrk);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_rvlsrk */
  } /*if (f2py_success) of d2000*/
  /* End of cleaning variable d2000 */
  } /*if (f2py_success) of r2000*/
  /* End of cleaning variable r2000 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_rvlsrk *****************************/

/********************************** sla_s2tp **********************************/
static char doc_f2py_rout_slalib_sla_s2tp[] = "\
Function signature:\n\
  xi,eta,j = sla_s2tp(ra,dec,raz,decz)\n\
Required arguments:\n"
"  ra : input float\n"
"  dec : input float\n"
"  raz : input float\n"
"  decz : input float\n"
"Return objects:\n"
"  xi : float\n"
"  eta : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_s2tp,SLA_S2TP)(float*,float*,float*,float*,float*,float*,int*); */
static PyObject *f2py_rout_slalib_sla_s2tp(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,float*,float*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float ra = 0;
  PyObject *ra_capi = Py_None;
  float dec = 0;
  PyObject *dec_capi = Py_None;
  float raz = 0;
  PyObject *raz_capi = Py_None;
  float decz = 0;
  PyObject *decz_capi = Py_None;
  float xi = 0;
  float eta = 0;
  int j = 0;
  static char *capi_kwlist[] = {"ra","dec","raz","decz",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_s2tp",\
    capi_kwlist,&ra_capi,&dec_capi,&raz_capi,&decz_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable xi */
  /* Processing variable ra */
    f2py_success = float_from_pyobj(&ra,ra_capi,"slalib.sla_s2tp() 1st argument (ra) can't be converted to float");
  if (f2py_success) {
  /* Processing variable decz */
    f2py_success = float_from_pyobj(&decz,decz_capi,"slalib.sla_s2tp() 4th argument (decz) can't be converted to float");
  if (f2py_success) {
  /* Processing variable eta */
  /* Processing variable raz */
    f2py_success = float_from_pyobj(&raz,raz_capi,"slalib.sla_s2tp() 3rd argument (raz) can't be converted to float");
  if (f2py_success) {
  /* Processing variable j */
  /* Processing variable dec */
    f2py_success = float_from_pyobj(&dec,dec_capi,"slalib.sla_s2tp() 2nd argument (dec) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&ra,&dec,&raz,&decz,&xi,&eta,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ffi",xi,eta,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of dec*/
  /* End of cleaning variable dec */
  /* End of cleaning variable j */
  } /*if (f2py_success) of raz*/
  /* End of cleaning variable raz */
  /* End of cleaning variable eta */
  } /*if (f2py_success) of decz*/
  /* End of cleaning variable decz */
  } /*if (f2py_success) of ra*/
  /* End of cleaning variable ra */
  /* End of cleaning variable xi */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_s2tp ******************************/

/********************************** sla_sep **********************************/
static char doc_f2py_rout_slalib_sla_sep[] = "\
Function signature:\n\
  sla_sep = sla_sep(a1,b1,a2,b2)\n\
Required arguments:\n"
"  a1 : input float\n"
"  b1 : input float\n"
"  a2 : input float\n"
"  b2 : input float\n"
"Return objects:\n"
"  sla_sep : float";
/* extern void F_WRAPPEDFUNC_US(sla_sep,SLA_SEP)(float*,float*,float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_sep(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_sep = 0;
  float a1 = 0;
  PyObject *a1_capi = Py_None;
  float b1 = 0;
  PyObject *b1_capi = Py_None;
  float a2 = 0;
  PyObject *a2_capi = Py_None;
  float b2 = 0;
  PyObject *b2_capi = Py_None;
  static char *capi_kwlist[] = {"a1","b1","a2","b2",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_sep",\
    capi_kwlist,&a1_capi,&b1_capi,&a2_capi,&b2_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a1 */
    f2py_success = float_from_pyobj(&a1,a1_capi,"slalib.sla_sep() 1st argument (a1) can't be converted to float");
  if (f2py_success) {
  /* Processing variable a2 */
    f2py_success = float_from_pyobj(&a2,a2_capi,"slalib.sla_sep() 3rd argument (a2) can't be converted to float");
  if (f2py_success) {
  /* Processing variable sla_sep */
  /* Processing variable b1 */
    f2py_success = float_from_pyobj(&b1,b1_capi,"slalib.sla_sep() 2nd argument (b1) can't be converted to float");
  if (f2py_success) {
  /* Processing variable b2 */
    f2py_success = float_from_pyobj(&b2,b2_capi,"slalib.sla_sep() 4th argument (b2) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_sep,&a1,&b1,&a2,&b2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_sep);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of b2*/
  /* End of cleaning variable b2 */
  } /*if (f2py_success) of b1*/
  /* End of cleaning variable b1 */
  /* End of cleaning variable sla_sep */
  } /*if (f2py_success) of a2*/
  /* End of cleaning variable a2 */
  } /*if (f2py_success) of a1*/
  /* End of cleaning variable a1 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_sep *******************************/

/********************************** sla_sepv **********************************/
static char doc_f2py_rout_slalib_sla_sepv[] = "\
Function signature:\n\
  sla_sepv = sla_sepv(v1,v2)\n\
Required arguments:\n"
"  v1 : input rank-1 array('f') with bounds (3)\n"
"  v2 : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  sla_sepv : float";
/* extern void F_WRAPPEDFUNC_US(sla_sepv,SLA_SEPV)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_sepv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_sepv = 0;
  float *v1 = NULL;
  npy_intp v1_Dims[1] = {-1};
  const int v1_Rank = 1;
  PyArrayObject *capi_v1_tmp = NULL;
  int capi_v1_intent = 0;
  PyObject *v1_capi = Py_None;
  float *v2 = NULL;
  npy_intp v2_Dims[1] = {-1};
  const int v2_Rank = 1;
  PyArrayObject *capi_v2_tmp = NULL;
  int capi_v2_intent = 0;
  PyObject *v2_capi = Py_None;
  static char *capi_kwlist[] = {"v1","v2",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_sepv",\
    capi_kwlist,&v1_capi,&v2_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable v1 */
  v1_Dims[0]=3;
  capi_v1_intent |= F2PY_INTENT_IN;
  capi_v1_tmp = array_from_pyobj(PyArray_FLOAT,v1_Dims,v1_Rank,capi_v1_intent,v1_capi);
  if (capi_v1_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v1' of slalib.sla_sepv to C/Fortran array" );
  } else {
    v1 = (float *)(capi_v1_tmp->data);

  /* Processing variable v2 */
  v2_Dims[0]=3;
  capi_v2_intent |= F2PY_INTENT_IN;
  capi_v2_tmp = array_from_pyobj(PyArray_FLOAT,v2_Dims,v2_Rank,capi_v2_intent,v2_capi);
  if (capi_v2_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `v2' of slalib.sla_sepv to C/Fortran array" );
  } else {
    v2 = (float *)(capi_v2_tmp->data);

  /* Processing variable sla_sepv */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_sepv,v1,v2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_sepv);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_sepv */
  if((PyObject *)capi_v2_tmp!=v2_capi) {
    Py_XDECREF(capi_v2_tmp); }
  }  /*if (capi_v2_tmp == NULL) ... else of v2*/
  /* End of cleaning variable v2 */
  if((PyObject *)capi_v1_tmp!=v1_capi) {
    Py_XDECREF(capi_v1_tmp); }
  }  /*if (capi_v1_tmp == NULL) ... else of v1*/
  /* End of cleaning variable v1 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_sepv ******************************/

/********************************** sla_smat **********************************/
static char doc_f2py_rout_slalib_sla_smat[] = "\
Function signature:\n\
  a,y,d,jf,iw = sla_smat(a,y,iw,[n])\n\
Required arguments:\n"
"  a : input rank-2 array('f') with bounds (n,n)\n"
"  y : input rank-1 array('f') with bounds (n)\n"
"  iw : input rank-1 array('i') with bounds (n)\n"
"Optional arguments:\n"
"  n := shape(a,0) input int\n"
"Return objects:\n"
"  a : rank-2 array('f') with bounds (n,n)\n"
"  y : rank-1 array('f') with bounds (n)\n"
"  d : float\n"
"  jf : int\n"
"  iw : rank-1 array('i') with bounds (n)";
/* extern void F_FUNC_US(sla_smat,SLA_SMAT)(int*,float*,float*,float*,int*,int*); */
static PyObject *f2py_rout_slalib_sla_smat(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,float*,float*,float*,int*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int n = 0;
  PyObject *n_capi = Py_None;
  float *a = NULL;
  npy_intp a_Dims[2] = {-1, -1};
  const int a_Rank = 2;
  PyArrayObject *capi_a_tmp = NULL;
  int capi_a_intent = 0;
  PyObject *a_capi = Py_None;
  float *y = NULL;
  npy_intp y_Dims[1] = {-1};
  const int y_Rank = 1;
  PyArrayObject *capi_y_tmp = NULL;
  int capi_y_intent = 0;
  PyObject *y_capi = Py_None;
  float d = 0;
  int jf = 0;
  int *iw = NULL;
  npy_intp iw_Dims[1] = {-1};
  const int iw_Rank = 1;
  PyArrayObject *capi_iw_tmp = NULL;
  int capi_iw_intent = 0;
  PyObject *iw_capi = Py_None;
  static char *capi_kwlist[] = {"a","y","iw","n",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|O:slalib.sla_smat",\
    capi_kwlist,&a_capi,&y_capi,&iw_capi,&n_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
  ;
  capi_a_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_a_tmp = array_from_pyobj(PyArray_FLOAT,a_Dims,a_Rank,capi_a_intent,a_capi);
  if (capi_a_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `a' of slalib.sla_smat to C/Fortran array" );
  } else {
    a = (float *)(capi_a_tmp->data);

  /* Processing variable d */
  /* Processing variable jf */
  /* Processing variable n */
  if (n_capi == Py_None) n = shape(a,0); else
    f2py_success = int_from_pyobj(&n,n_capi,"slalib.sla_smat() 1st keyword (n) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(shape(a,0)==n,"shape(a,0)==n","1st keyword n","sla_smat:n=%d",n) {
  /* Processing variable y */
  y_Dims[0]=n;
  capi_y_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_y_tmp = array_from_pyobj(PyArray_FLOAT,y_Dims,y_Rank,capi_y_intent,y_capi);
  if (capi_y_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `y' of slalib.sla_smat to C/Fortran array" );
  } else {
    y = (float *)(capi_y_tmp->data);

  /* Processing variable iw */
  iw_Dims[0]=n;
  capi_iw_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_iw_tmp = array_from_pyobj(PyArray_INT,iw_Dims,iw_Rank,capi_iw_intent,iw_capi);
  if (capi_iw_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `iw' of slalib.sla_smat to C/Fortran array" );
  } else {
    iw = (int *)(capi_iw_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&n,a,y,&d,&jf,iw);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("NNfiN",capi_a_tmp,capi_y_tmp,d,jf,capi_iw_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_iw_tmp == NULL) ... else of iw*/
  /* End of cleaning variable iw */
  }  /*if (capi_y_tmp == NULL) ... else of y*/
  /* End of cleaning variable y */
  } /*CHECKSCALAR(shape(a,0)==n)*/
  } /*if (f2py_success) of n*/
  /* End of cleaning variable n */
  /* End of cleaning variable jf */
  /* End of cleaning variable d */
  }  /*if (capi_a_tmp == NULL) ... else of a*/
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_smat ******************************/

/********************************* sla_subet *********************************/
static char doc_f2py_rout_slalib_sla_subet[] = "\
Function signature:\n\
  rm,dm = sla_subet(rc,dc,eq)\n\
Required arguments:\n"
"  rc : input float\n"
"  dc : input float\n"
"  eq : input float\n"
"Return objects:\n"
"  rm : float\n"
"  dm : float";
/* extern void F_FUNC_US(sla_subet,SLA_SUBET)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_subet(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double rc = 0;
  PyObject *rc_capi = Py_None;
  double dc = 0;
  PyObject *dc_capi = Py_None;
  double eq = 0;
  PyObject *eq_capi = Py_None;
  double rm = 0;
  double dm = 0;
  static char *capi_kwlist[] = {"rc","dc","eq",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_subet",\
    capi_kwlist,&rc_capi,&dc_capi,&eq_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable rm */
  /* Processing variable dm */
  /* Processing variable eq */
    f2py_success = double_from_pyobj(&eq,eq_capi,"slalib.sla_subet() 3rd argument (eq) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dc */
    f2py_success = double_from_pyobj(&dc,dc_capi,"slalib.sla_subet() 2nd argument (dc) can't be converted to double");
  if (f2py_success) {
  /* Processing variable rc */
    f2py_success = double_from_pyobj(&rc,rc_capi,"slalib.sla_subet() 1st argument (rc) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&rc,&dc,&eq,&rm,&dm);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",rm,dm);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of rc*/
  /* End of cleaning variable rc */
  } /*if (f2py_success) of dc*/
  /* End of cleaning variable dc */
  } /*if (f2py_success) of eq*/
  /* End of cleaning variable eq */
  /* End of cleaning variable dm */
  /* End of cleaning variable rm */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_subet ******************************/

/********************************* sla_supgal *********************************/
static char doc_f2py_rout_slalib_sla_supgal[] = "\
Function signature:\n\
  dl,db = sla_supgal(dsl,dsb)\n\
Required arguments:\n"
"  dsl : input float\n"
"  dsb : input float\n"
"Return objects:\n"
"  dl : float\n"
"  db : float";
/* extern void F_FUNC_US(sla_supgal,SLA_SUPGAL)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_supgal(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double dsl = 0;
  PyObject *dsl_capi = Py_None;
  double dsb = 0;
  PyObject *dsb_capi = Py_None;
  double dl = 0;
  double db = 0;
  static char *capi_kwlist[] = {"dsl","dsb",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_supgal",\
    capi_kwlist,&dsl_capi,&dsb_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dsb */
    f2py_success = double_from_pyobj(&dsb,dsb_capi,"slalib.sla_supgal() 2nd argument (dsb) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dsl */
    f2py_success = double_from_pyobj(&dsl,dsl_capi,"slalib.sla_supgal() 1st argument (dsl) can't be converted to double");
  if (f2py_success) {
  /* Processing variable db */
  /* Processing variable dl */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&dsl,&dsb,&dl,&db);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",dl,db);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable dl */
  /* End of cleaning variable db */
  } /*if (f2py_success) of dsl*/
  /* End of cleaning variable dsl */
  } /*if (f2py_success) of dsb*/
  /* End of cleaning variable dsb */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_supgal *****************************/

/********************************* sla_svdcov *********************************/
static char doc_f2py_rout_slalib_sla_svdcov[] = "\
Function signature:\n\
  work,cvm = sla_svdcov(w,v,[n,np,nc])\n\
Required arguments:\n"
"  w : input rank-1 array('d') with bounds (n)\n"
"  v : input rank-2 array('d') with bounds (np,np)\n"
"Optional arguments:\n"
"  n := len(w) input int\n"
"  np := shape(v,0) input int\n"
"  nc := n input int\n"
"Return objects:\n"
"  work : rank-1 array('d') with bounds (n)\n"
"  cvm : rank-2 array('d') with bounds (n,n)";
/* extern void F_FUNC_US(sla_svdcov,SLA_SVDCOV)(int*,int*,int*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_svdcov(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,int*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int n = 0;
  PyObject *n_capi = Py_None;
  int np = 0;
  PyObject *np_capi = Py_None;
  int nc = 0;
  PyObject *nc_capi = Py_None;
  double *w = NULL;
  npy_intp w_Dims[1] = {-1};
  const int w_Rank = 1;
  PyArrayObject *capi_w_tmp = NULL;
  int capi_w_intent = 0;
  PyObject *w_capi = Py_None;
  double *v = NULL;
  npy_intp v_Dims[2] = {-1, -1};
  const int v_Rank = 2;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  double *work = NULL;
  npy_intp work_Dims[1] = {-1};
  const int work_Rank = 1;
  PyArrayObject *capi_work_tmp = NULL;
  int capi_work_intent = 0;
  double *cvm = NULL;
  npy_intp cvm_Dims[2] = {-1, -1};
  const int cvm_Rank = 2;
  PyArrayObject *capi_cvm_tmp = NULL;
  int capi_cvm_intent = 0;
  static char *capi_kwlist[] = {"w","v","n","np","nc",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|OOO:slalib.sla_svdcov",\
    capi_kwlist,&w_capi,&v_capi,&n_capi,&np_capi,&nc_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable w */
  ;
  capi_w_intent |= F2PY_INTENT_IN;
  capi_w_tmp = array_from_pyobj(PyArray_DOUBLE,w_Dims,w_Rank,capi_w_intent,w_capi);
  if (capi_w_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `w' of slalib.sla_svdcov to C/Fortran array" );
  } else {
    w = (double *)(capi_w_tmp->data);

  /* Processing variable v */
  ;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_DOUBLE,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `v' of slalib.sla_svdcov to C/Fortran array" );
  } else {
    v = (double *)(capi_v_tmp->data);

  /* Processing variable np */
  if (np_capi == Py_None) np = shape(v,0); else
    f2py_success = int_from_pyobj(&np,np_capi,"slalib.sla_svdcov() 2nd keyword (np) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(shape(v,0)==np,"shape(v,0)==np","2nd keyword np","sla_svdcov:np=%d",np) {
  /* Processing variable n */
  if (n_capi == Py_None) n = len(w); else
    f2py_success = int_from_pyobj(&n,n_capi,"slalib.sla_svdcov() 1st keyword (n) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(len(w)>=n,"len(w)>=n","1st keyword n","sla_svdcov:n=%d",n) {
  /* Processing variable nc */
  if (nc_capi == Py_None) nc = n; else
    f2py_success = int_from_pyobj(&nc,nc_capi,"slalib.sla_svdcov() 3rd keyword (nc) can't be converted to int");
  if (f2py_success) {
  /* Processing variable work */
  work_Dims[0]=n;
  capi_work_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_work_tmp = array_from_pyobj(PyArray_DOUBLE,work_Dims,work_Rank,capi_work_intent,Py_None);
  if (capi_work_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `work' of slalib.sla_svdcov to C/Fortran array" );
  } else {
    work = (double *)(capi_work_tmp->data);

  /* Processing variable cvm */
  cvm_Dims[0]=n,cvm_Dims[1]=n;
  capi_cvm_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_cvm_tmp = array_from_pyobj(PyArray_DOUBLE,cvm_Dims,cvm_Rank,capi_cvm_intent,Py_None);
  if (capi_cvm_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `cvm' of slalib.sla_svdcov to C/Fortran array" );
  } else {
    cvm = (double *)(capi_cvm_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&n,&np,&nc,w,v,work,cvm);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("NN",capi_work_tmp,capi_cvm_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_cvm_tmp == NULL) ... else of cvm*/
  /* End of cleaning variable cvm */
  }  /*if (capi_work_tmp == NULL) ... else of work*/
  /* End of cleaning variable work */
  } /*if (f2py_success) of nc*/
  /* End of cleaning variable nc */
  } /*CHECKSCALAR(len(w)>=n)*/
  } /*if (f2py_success) of n*/
  /* End of cleaning variable n */
  } /*CHECKSCALAR(shape(v,0)==np)*/
  } /*if (f2py_success) of np*/
  /* End of cleaning variable np */
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  if((PyObject *)capi_w_tmp!=w_capi) {
    Py_XDECREF(capi_w_tmp); }
  }  /*if (capi_w_tmp == NULL) ... else of w*/
  /* End of cleaning variable w */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_svdcov *****************************/

/********************************** sla_svd **********************************/
static char doc_f2py_rout_slalib_sla_svd[] = "\
Function signature:\n\
  a,w,v,work,jstat = sla_svd(m,n,a,[mp,np])\n\
Required arguments:\n"
"  m : input int\n"
"  n : input int\n"
"  a : input rank-2 array('d') with bounds (mp,np)\n"
"Optional arguments:\n"
"  mp := shape(a,0) input int\n"
"  np := shape(a,1) input int\n"
"Return objects:\n"
"  a : rank-2 array('d') with bounds (mp,np)\n"
"  w : rank-1 array('d') with bounds (n)\n"
"  v : rank-2 array('d') with bounds (np,np)\n"
"  work : rank-1 array('d') with bounds (n)\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_svd,SLA_SVD)(int*,int*,int*,int*,double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_svd(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,int*,int*,double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int m = 0;
  PyObject *m_capi = Py_None;
  int n = 0;
  PyObject *n_capi = Py_None;
  int mp = 0;
  PyObject *mp_capi = Py_None;
  int np = 0;
  PyObject *np_capi = Py_None;
  double *a = NULL;
  npy_intp a_Dims[2] = {-1, -1};
  const int a_Rank = 2;
  PyArrayObject *capi_a_tmp = NULL;
  int capi_a_intent = 0;
  PyObject *a_capi = Py_None;
  double *w = NULL;
  npy_intp w_Dims[1] = {-1};
  const int w_Rank = 1;
  PyArrayObject *capi_w_tmp = NULL;
  int capi_w_intent = 0;
  double *v = NULL;
  npy_intp v_Dims[2] = {-1, -1};
  const int v_Rank = 2;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  double *work = NULL;
  npy_intp work_Dims[1] = {-1};
  const int work_Rank = 1;
  PyArrayObject *capi_work_tmp = NULL;
  int capi_work_intent = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"m","n","a","mp","np",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|OO:slalib.sla_svd",\
    capi_kwlist,&m_capi,&n_capi,&a_capi,&mp_capi,&np_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable a */
  ;
  capi_a_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_a_tmp = array_from_pyobj(PyArray_DOUBLE,a_Dims,a_Rank,capi_a_intent,a_capi);
  if (capi_a_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `a' of slalib.sla_svd to C/Fortran array" );
  } else {
    a = (double *)(capi_a_tmp->data);

  /* Processing variable m */
    f2py_success = int_from_pyobj(&m,m_capi,"slalib.sla_svd() 1st argument (m) can't be converted to int");
  if (f2py_success) {
  /* Processing variable n */
    f2py_success = int_from_pyobj(&n,n_capi,"slalib.sla_svd() 2nd argument (n) can't be converted to int");
  if (f2py_success) {
  /* Processing variable jstat */
  /* Processing variable work */
  work_Dims[0]=n;
  capi_work_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_work_tmp = array_from_pyobj(PyArray_DOUBLE,work_Dims,work_Rank,capi_work_intent,Py_None);
  if (capi_work_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `work' of slalib.sla_svd to C/Fortran array" );
  } else {
    work = (double *)(capi_work_tmp->data);

  /* Processing variable mp */
  if (mp_capi == Py_None) mp = shape(a,0); else
    f2py_success = int_from_pyobj(&mp,mp_capi,"slalib.sla_svd() 1st keyword (mp) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(shape(a,0)==mp,"shape(a,0)==mp","1st keyword mp","sla_svd:mp=%d",mp) {
  /* Processing variable w */
  w_Dims[0]=n;
  capi_w_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_w_tmp = array_from_pyobj(PyArray_DOUBLE,w_Dims,w_Rank,capi_w_intent,Py_None);
  if (capi_w_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `w' of slalib.sla_svd to C/Fortran array" );
  } else {
    w = (double *)(capi_w_tmp->data);

  /* Processing variable np */
  if (np_capi == Py_None) np = shape(a,1); else
    f2py_success = int_from_pyobj(&np,np_capi,"slalib.sla_svd() 2nd keyword (np) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(shape(a,1)==np,"shape(a,1)==np","2nd keyword np","sla_svd:np=%d",np) {
  /* Processing variable v */
  v_Dims[0]=np,v_Dims[1]=np;
  capi_v_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_v_tmp = array_from_pyobj(PyArray_DOUBLE,v_Dims,v_Rank,capi_v_intent,Py_None);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `v' of slalib.sla_svd to C/Fortran array" );
  } else {
    v = (double *)(capi_v_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&m,&n,&mp,&np,a,w,v,work,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("NNNNi",capi_a_tmp,capi_w_tmp,capi_v_tmp,capi_work_tmp,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  } /*CHECKSCALAR(shape(a,1)==np)*/
  } /*if (f2py_success) of np*/
  /* End of cleaning variable np */
  }  /*if (capi_w_tmp == NULL) ... else of w*/
  /* End of cleaning variable w */
  } /*CHECKSCALAR(shape(a,0)==mp)*/
  } /*if (f2py_success) of mp*/
  /* End of cleaning variable mp */
  }  /*if (capi_work_tmp == NULL) ... else of work*/
  /* End of cleaning variable work */
  /* End of cleaning variable jstat */
  } /*if (f2py_success) of n*/
  /* End of cleaning variable n */
  } /*if (f2py_success) of m*/
  /* End of cleaning variable m */
  }  /*if (capi_a_tmp == NULL) ... else of a*/
  /* End of cleaning variable a */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_svd *******************************/

/********************************* sla_svdsol *********************************/
static char doc_f2py_rout_slalib_sla_svdsol[] = "\
Function signature:\n\
  work,x = sla_svdsol(b,u,w,v,[m,n,mp,np])\n\
Required arguments:\n"
"  b : input rank-1 array('d') with bounds (m)\n"
"  u : input rank-2 array('d') with bounds (mp,np)\n"
"  w : input rank-1 array('d') with bounds (n)\n"
"  v : input rank-2 array('d') with bounds (np,np)\n"
"Optional arguments:\n"
"  m := len(b) input int\n"
"  n := len(w) input int\n"
"  mp := shape(u,0) input int\n"
"  np := shape(u,1) input int\n"
"Return objects:\n"
"  work : rank-1 array('d') with bounds (n)\n"
"  x : rank-1 array('d') with bounds (n)";
/* extern void F_FUNC_US(sla_svdsol,SLA_SVDSOL)(int*,int*,int*,int*,double*,double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_svdsol(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*,int*,int*,int*,double*,double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int m = 0;
  PyObject *m_capi = Py_None;
  int n = 0;
  PyObject *n_capi = Py_None;
  int mp = 0;
  PyObject *mp_capi = Py_None;
  int np = 0;
  PyObject *np_capi = Py_None;
  double *b = NULL;
  npy_intp b_Dims[1] = {-1};
  const int b_Rank = 1;
  PyArrayObject *capi_b_tmp = NULL;
  int capi_b_intent = 0;
  PyObject *b_capi = Py_None;
  double *u = NULL;
  npy_intp u_Dims[2] = {-1, -1};
  const int u_Rank = 2;
  PyArrayObject *capi_u_tmp = NULL;
  int capi_u_intent = 0;
  PyObject *u_capi = Py_None;
  double *w = NULL;
  npy_intp w_Dims[1] = {-1};
  const int w_Rank = 1;
  PyArrayObject *capi_w_tmp = NULL;
  int capi_w_intent = 0;
  PyObject *w_capi = Py_None;
  double *v = NULL;
  npy_intp v_Dims[2] = {-1, -1};
  const int v_Rank = 2;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  double *work = NULL;
  npy_intp work_Dims[1] = {-1};
  const int work_Rank = 1;
  PyArrayObject *capi_work_tmp = NULL;
  int capi_work_intent = 0;
  double *x = NULL;
  npy_intp x_Dims[1] = {-1};
  const int x_Rank = 1;
  PyArrayObject *capi_x_tmp = NULL;
  int capi_x_intent = 0;
  static char *capi_kwlist[] = {"b","u","w","v","m","n","mp","np",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|OOOO:slalib.sla_svdsol",\
    capi_kwlist,&b_capi,&u_capi,&w_capi,&v_capi,&m_capi,&n_capi,&mp_capi,&np_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable b */
  ;
  capi_b_intent |= F2PY_INTENT_IN;
  capi_b_tmp = array_from_pyobj(PyArray_DOUBLE,b_Dims,b_Rank,capi_b_intent,b_capi);
  if (capi_b_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `b' of slalib.sla_svdsol to C/Fortran array" );
  } else {
    b = (double *)(capi_b_tmp->data);

  /* Processing variable u */
  ;
  capi_u_intent |= F2PY_INTENT_IN;
  capi_u_tmp = array_from_pyobj(PyArray_DOUBLE,u_Dims,u_Rank,capi_u_intent,u_capi);
  if (capi_u_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `u' of slalib.sla_svdsol to C/Fortran array" );
  } else {
    u = (double *)(capi_u_tmp->data);

  /* Processing variable w */
  ;
  capi_w_intent |= F2PY_INTENT_IN;
  capi_w_tmp = array_from_pyobj(PyArray_DOUBLE,w_Dims,w_Rank,capi_w_intent,w_capi);
  if (capi_w_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `w' of slalib.sla_svdsol to C/Fortran array" );
  } else {
    w = (double *)(capi_w_tmp->data);

  /* Processing variable m */
  if (m_capi == Py_None) m = len(b); else
    f2py_success = int_from_pyobj(&m,m_capi,"slalib.sla_svdsol() 1st keyword (m) can't be converted to int");
  if (f2py_success) {
  /* Processing variable n */
  if (n_capi == Py_None) n = len(w); else
    f2py_success = int_from_pyobj(&n,n_capi,"slalib.sla_svdsol() 2nd keyword (n) can't be converted to int");
  if (f2py_success) {
  /* Processing variable mp */
  if (mp_capi == Py_None) mp = shape(u,0); else
    f2py_success = int_from_pyobj(&mp,mp_capi,"slalib.sla_svdsol() 3rd keyword (mp) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(shape(u,0)==mp,"shape(u,0)==mp","3rd keyword mp","sla_svdsol:mp=%d",mp) {
  /* Processing variable np */
  if (np_capi == Py_None) np = shape(u,1); else
    f2py_success = int_from_pyobj(&np,np_capi,"slalib.sla_svdsol() 4th keyword (np) can't be converted to int");
  if (f2py_success) {
  CHECKSCALAR(shape(u,1)==np,"shape(u,1)==np","4th keyword np","sla_svdsol:np=%d",np) {
  /* Processing variable x */
  x_Dims[0]=n;
  capi_x_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_x_tmp = array_from_pyobj(PyArray_DOUBLE,x_Dims,x_Rank,capi_x_intent,Py_None);
  if (capi_x_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `x' of slalib.sla_svdsol to C/Fortran array" );
  } else {
    x = (double *)(capi_x_tmp->data);

  /* Processing variable work */
  work_Dims[0]=n;
  capi_work_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_work_tmp = array_from_pyobj(PyArray_DOUBLE,work_Dims,work_Rank,capi_work_intent,Py_None);
  if (capi_work_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `work' of slalib.sla_svdsol to C/Fortran array" );
  } else {
    work = (double *)(capi_work_tmp->data);

  /* Processing variable v */
  v_Dims[0]=np,v_Dims[1]=np;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_DOUBLE,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 4th argument `v' of slalib.sla_svdsol to C/Fortran array" );
  } else {
    v = (double *)(capi_v_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&m,&n,&mp,&np,b,u,w,v,work,x);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("NN",capi_work_tmp,capi_x_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  }  /*if (capi_work_tmp == NULL) ... else of work*/
  /* End of cleaning variable work */
  }  /*if (capi_x_tmp == NULL) ... else of x*/
  /* End of cleaning variable x */
  } /*CHECKSCALAR(shape(u,1)==np)*/
  } /*if (f2py_success) of np*/
  /* End of cleaning variable np */
  } /*CHECKSCALAR(shape(u,0)==mp)*/
  } /*if (f2py_success) of mp*/
  /* End of cleaning variable mp */
  } /*if (f2py_success) of n*/
  /* End of cleaning variable n */
  } /*if (f2py_success) of m*/
  /* End of cleaning variable m */
  if((PyObject *)capi_w_tmp!=w_capi) {
    Py_XDECREF(capi_w_tmp); }
  }  /*if (capi_w_tmp == NULL) ... else of w*/
  /* End of cleaning variable w */
  if((PyObject *)capi_u_tmp!=u_capi) {
    Py_XDECREF(capi_u_tmp); }
  }  /*if (capi_u_tmp == NULL) ... else of u*/
  /* End of cleaning variable u */
  if((PyObject *)capi_b_tmp!=b_capi) {
    Py_XDECREF(capi_b_tmp); }
  }  /*if (capi_b_tmp == NULL) ... else of b*/
  /* End of cleaning variable b */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/***************************** end of sla_svdsol *****************************/

/********************************** sla_tp2s **********************************/
static char doc_f2py_rout_slalib_sla_tp2s[] = "\
Function signature:\n\
  ra,dec = sla_tp2s(xi,eta,raz,decz)\n\
Required arguments:\n"
"  xi : input float\n"
"  eta : input float\n"
"  raz : input float\n"
"  decz : input float\n"
"Return objects:\n"
"  ra : float\n"
"  dec : float";
/* extern void F_FUNC_US(sla_tp2s,SLA_TP2S)(float*,float*,float*,float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_tp2s(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float xi = 0;
  PyObject *xi_capi = Py_None;
  float eta = 0;
  PyObject *eta_capi = Py_None;
  float raz = 0;
  PyObject *raz_capi = Py_None;
  float decz = 0;
  PyObject *decz_capi = Py_None;
  float ra = 0;
  float dec = 0;
  static char *capi_kwlist[] = {"xi","eta","raz","decz",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_tp2s",\
    capi_kwlist,&xi_capi,&eta_capi,&raz_capi,&decz_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable xi */
    f2py_success = float_from_pyobj(&xi,xi_capi,"slalib.sla_tp2s() 1st argument (xi) can't be converted to float");
  if (f2py_success) {
  /* Processing variable ra */
  /* Processing variable decz */
    f2py_success = float_from_pyobj(&decz,decz_capi,"slalib.sla_tp2s() 4th argument (decz) can't be converted to float");
  if (f2py_success) {
  /* Processing variable eta */
    f2py_success = float_from_pyobj(&eta,eta_capi,"slalib.sla_tp2s() 2nd argument (eta) can't be converted to float");
  if (f2py_success) {
  /* Processing variable dec */
  /* Processing variable raz */
    f2py_success = float_from_pyobj(&raz,raz_capi,"slalib.sla_tp2s() 3rd argument (raz) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&xi,&eta,&raz,&decz,&ra,&dec);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ff",ra,dec);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of raz*/
  /* End of cleaning variable raz */
  /* End of cleaning variable dec */
  } /*if (f2py_success) of eta*/
  /* End of cleaning variable eta */
  } /*if (f2py_success) of decz*/
  /* End of cleaning variable decz */
  /* End of cleaning variable ra */
  } /*if (f2py_success) of xi*/
  /* End of cleaning variable xi */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_tp2s ******************************/

/********************************** sla_tp2v **********************************/
static char doc_f2py_rout_slalib_sla_tp2v[] = "\
Function signature:\n\
  v = sla_tp2v(xi,eta,v0)\n\
Required arguments:\n"
"  xi : input float\n"
"  eta : input float\n"
"  v0 : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  v : rank-1 array('f') with bounds (3)";
/* extern void F_FUNC_US(sla_tp2v,SLA_TP2V)(float*,float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_tp2v(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float xi = 0;
  PyObject *xi_capi = Py_None;
  float eta = 0;
  PyObject *eta_capi = Py_None;
  float *v0 = NULL;
  npy_intp v0_Dims[1] = {-1};
  const int v0_Rank = 1;
  PyArrayObject *capi_v0_tmp = NULL;
  int capi_v0_intent = 0;
  PyObject *v0_capi = Py_None;
  float *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  static char *capi_kwlist[] = {"xi","eta","v0",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_tp2v",\
    capi_kwlist,&xi_capi,&eta_capi,&v0_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable v0 */
  v0_Dims[0]=3;
  capi_v0_intent |= F2PY_INTENT_IN;
  capi_v0_tmp = array_from_pyobj(PyArray_FLOAT,v0_Dims,v0_Rank,capi_v0_intent,v0_capi);
  if (capi_v0_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `v0' of slalib.sla_tp2v to C/Fortran array" );
  } else {
    v0 = (float *)(capi_v0_tmp->data);

  /* Processing variable eta */
    f2py_success = float_from_pyobj(&eta,eta_capi,"slalib.sla_tp2v() 2nd argument (eta) can't be converted to float");
  if (f2py_success) {
  /* Processing variable xi */
    f2py_success = float_from_pyobj(&xi,xi_capi,"slalib.sla_tp2v() 1st argument (xi) can't be converted to float");
  if (f2py_success) {
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_v_tmp = array_from_pyobj(PyArray_FLOAT,v_Dims,v_Rank,capi_v_intent,Py_None);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `v' of slalib.sla_tp2v to C/Fortran array" );
  } else {
    v = (float *)(capi_v_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&xi,&eta,v0,v);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_v_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  } /*if (f2py_success) of xi*/
  /* End of cleaning variable xi */
  } /*if (f2py_success) of eta*/
  /* End of cleaning variable eta */
  if((PyObject *)capi_v0_tmp!=v0_capi) {
    Py_XDECREF(capi_v0_tmp); }
  }  /*if (capi_v0_tmp == NULL) ... else of v0*/
  /* End of cleaning variable v0 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_tp2v ******************************/

/********************************* sla_tps2c *********************************/
static char doc_f2py_rout_slalib_sla_tps2c[] = "\
Function signature:\n\
  raz1,decz1,raz2,decz2,n = sla_tps2c(xi,eta,ra,dec)\n\
Required arguments:\n"
"  xi : input float\n"
"  eta : input float\n"
"  ra : input float\n"
"  dec : input float\n"
"Return objects:\n"
"  raz1 : float\n"
"  decz1 : float\n"
"  raz2 : float\n"
"  decz2 : float\n"
"  n : int";
/* extern void F_FUNC_US(sla_tps2c,SLA_TPS2C)(float*,float*,float*,float*,float*,float*,float*,float*,int*); */
static PyObject *f2py_rout_slalib_sla_tps2c(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,float*,float*,float*,float*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float xi = 0;
  PyObject *xi_capi = Py_None;
  float eta = 0;
  PyObject *eta_capi = Py_None;
  float ra = 0;
  PyObject *ra_capi = Py_None;
  float dec = 0;
  PyObject *dec_capi = Py_None;
  float raz1 = 0;
  float decz1 = 0;
  float raz2 = 0;
  float decz2 = 0;
  int n = 0;
  static char *capi_kwlist[] = {"xi","eta","ra","dec",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOOO|:slalib.sla_tps2c",\
    capi_kwlist,&xi_capi,&eta_capi,&ra_capi,&dec_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable decz2 */
  /* Processing variable decz1 */
  /* Processing variable xi */
    f2py_success = float_from_pyobj(&xi,xi_capi,"slalib.sla_tps2c() 1st argument (xi) can't be converted to float");
  if (f2py_success) {
  /* Processing variable raz1 */
  /* Processing variable raz2 */
  /* Processing variable n */
  /* Processing variable eta */
    f2py_success = float_from_pyobj(&eta,eta_capi,"slalib.sla_tps2c() 2nd argument (eta) can't be converted to float");
  if (f2py_success) {
  /* Processing variable ra */
    f2py_success = float_from_pyobj(&ra,ra_capi,"slalib.sla_tps2c() 3rd argument (ra) can't be converted to float");
  if (f2py_success) {
  /* Processing variable dec */
    f2py_success = float_from_pyobj(&dec,dec_capi,"slalib.sla_tps2c() 4th argument (dec) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&xi,&eta,&ra,&dec,&raz1,&decz1,&raz2,&decz2,&n);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ffffi",raz1,decz1,raz2,decz2,n);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of dec*/
  /* End of cleaning variable dec */
  } /*if (f2py_success) of ra*/
  /* End of cleaning variable ra */
  } /*if (f2py_success) of eta*/
  /* End of cleaning variable eta */
  /* End of cleaning variable n */
  /* End of cleaning variable raz2 */
  /* End of cleaning variable raz1 */
  } /*if (f2py_success) of xi*/
  /* End of cleaning variable xi */
  /* End of cleaning variable decz1 */
  /* End of cleaning variable decz2 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_tps2c ******************************/

/********************************* sla_tpv2c *********************************/
static char doc_f2py_rout_slalib_sla_tpv2c[] = "\
Function signature:\n\
  v01,v02,n = sla_tpv2c(xi,eta,v)\n\
Required arguments:\n"
"  xi : input float\n"
"  eta : input float\n"
"  v : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  v01 : rank-1 array('f') with bounds (3)\n"
"  v02 : rank-1 array('f') with bounds (3)\n"
"  n : int";
/* extern void F_FUNC_US(sla_tpv2c,SLA_TPV2C)(float*,float*,float*,float*,float*,int*); */
static PyObject *f2py_rout_slalib_sla_tpv2c(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,float*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float xi = 0;
  PyObject *xi_capi = Py_None;
  float eta = 0;
  PyObject *eta_capi = Py_None;
  float *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  float *v01 = NULL;
  npy_intp v01_Dims[1] = {-1};
  const int v01_Rank = 1;
  PyArrayObject *capi_v01_tmp = NULL;
  int capi_v01_intent = 0;
  float *v02 = NULL;
  npy_intp v02_Dims[1] = {-1};
  const int v02_Rank = 1;
  PyArrayObject *capi_v02_tmp = NULL;
  int capi_v02_intent = 0;
  int n = 0;
  static char *capi_kwlist[] = {"xi","eta","v",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_tpv2c",\
    capi_kwlist,&xi_capi,&eta_capi,&v_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable xi */
    f2py_success = float_from_pyobj(&xi,xi_capi,"slalib.sla_tpv2c() 1st argument (xi) can't be converted to float");
  if (f2py_success) {
  /* Processing variable v01 */
  v01_Dims[0]=3;
  capi_v01_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_v01_tmp = array_from_pyobj(PyArray_FLOAT,v01_Dims,v01_Rank,capi_v01_intent,Py_None);
  if (capi_v01_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `v01' of slalib.sla_tpv2c to C/Fortran array" );
  } else {
    v01 = (float *)(capi_v01_tmp->data);

  /* Processing variable v02 */
  v02_Dims[0]=3;
  capi_v02_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_v02_tmp = array_from_pyobj(PyArray_FLOAT,v02_Dims,v02_Rank,capi_v02_intent,Py_None);
  if (capi_v02_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `v02' of slalib.sla_tpv2c to C/Fortran array" );
  } else {
    v02 = (float *)(capi_v02_tmp->data);

  /* Processing variable eta */
    f2py_success = float_from_pyobj(&eta,eta_capi,"slalib.sla_tpv2c() 2nd argument (eta) can't be converted to float");
  if (f2py_success) {
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_FLOAT,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `v' of slalib.sla_tpv2c to C/Fortran array" );
  } else {
    v = (float *)(capi_v_tmp->data);

  /* Processing variable n */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&xi,&eta,v,v01,v02,&n);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("NNi",capi_v01_tmp,capi_v02_tmp,n);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable n */
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  } /*if (f2py_success) of eta*/
  /* End of cleaning variable eta */
  }  /*if (capi_v02_tmp == NULL) ... else of v02*/
  /* End of cleaning variable v02 */
  }  /*if (capi_v01_tmp == NULL) ... else of v01*/
  /* End of cleaning variable v01 */
  } /*if (f2py_success) of xi*/
  /* End of cleaning variable xi */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_tpv2c ******************************/

/********************************* sla_ue2el *********************************/
static char doc_f2py_rout_slalib_sla_ue2el[] = "\
Function signature:\n\
  jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm,jstat = sla_ue2el(u,jformr)\n\
Required arguments:\n"
"  u : input rank-1 array('d') with bounds (13)\n"
"  jformr : input int\n"
"Return objects:\n"
"  jform : int\n"
"  epoch : float\n"
"  orbinc : float\n"
"  anode : float\n"
"  perih : float\n"
"  aorq : float\n"
"  e : float\n"
"  aorl : float\n"
"  dm : float\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_ue2el,SLA_UE2EL)(double*,int*,int*,double*,double*,double*,double*,double*,double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_ue2el(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,int*,int*,double*,double*,double*,double*,double*,double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double *u = NULL;
  npy_intp u_Dims[1] = {-1};
  const int u_Rank = 1;
  PyArrayObject *capi_u_tmp = NULL;
  int capi_u_intent = 0;
  PyObject *u_capi = Py_None;
  int jformr = 0;
  PyObject *jformr_capi = Py_None;
  int jform = 0;
  double epoch = 0;
  double orbinc = 0;
  double anode = 0;
  double perih = 0;
  double aorq = 0;
  double e = 0;
  double aorl = 0;
  double dm = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"u","jformr",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_ue2el",\
    capi_kwlist,&u_capi,&jformr_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable dm */
  /* Processing variable e */
  /* Processing variable perih */
  /* Processing variable aorl */
  /* Processing variable epoch */
  /* Processing variable orbinc */
  /* Processing variable anode */
  /* Processing variable aorq */
  /* Processing variable u */
  u_Dims[0]=13;
  capi_u_intent |= F2PY_INTENT_IN;
  capi_u_tmp = array_from_pyobj(PyArray_DOUBLE,u_Dims,u_Rank,capi_u_intent,u_capi);
  if (capi_u_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `u' of slalib.sla_ue2el to C/Fortran array" );
  } else {
    u = (double *)(capi_u_tmp->data);

  /* Processing variable jformr */
    f2py_success = int_from_pyobj(&jformr,jformr_capi,"slalib.sla_ue2el() 2nd argument (jformr) can't be converted to int");
  if (f2py_success) {
  /* Processing variable jform */
  /* Processing variable jstat */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(u,&jformr,&jform,&epoch,&orbinc,&anode,&perih,&aorq,&e,&aorl,&dm,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("iddddddddi",jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable jstat */
  /* End of cleaning variable jform */
  } /*if (f2py_success) of jformr*/
  /* End of cleaning variable jformr */
  if((PyObject *)capi_u_tmp!=u_capi) {
    Py_XDECREF(capi_u_tmp); }
  }  /*if (capi_u_tmp == NULL) ... else of u*/
  /* End of cleaning variable u */
  /* End of cleaning variable aorq */
  /* End of cleaning variable anode */
  /* End of cleaning variable orbinc */
  /* End of cleaning variable epoch */
  /* End of cleaning variable aorl */
  /* End of cleaning variable perih */
  /* End of cleaning variable e */
  /* End of cleaning variable dm */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_ue2el ******************************/

/********************************* sla_ue2pv *********************************/
static char doc_f2py_rout_slalib_sla_ue2pv[] = "\
Function signature:\n\
  u,pv,jstat = sla_ue2pv(date,u)\n\
Required arguments:\n"
"  date : input float\n"
"  u : input rank-1 array('d') with bounds (13)\n"
"Return objects:\n"
"  u : rank-1 array('d') with bounds (13)\n"
"  pv : rank-1 array('d') with bounds (6)\n"
"  jstat : int";
/* extern void F_FUNC_US(sla_ue2pv,SLA_UE2PV)(double*,double*,double*,int*); */
static PyObject *f2py_rout_slalib_sla_ue2pv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double date = 0;
  PyObject *date_capi = Py_None;
  double *u = NULL;
  npy_intp u_Dims[1] = {-1};
  const int u_Rank = 1;
  PyArrayObject *capi_u_tmp = NULL;
  int capi_u_intent = 0;
  PyObject *u_capi = Py_None;
  double *pv = NULL;
  npy_intp pv_Dims[1] = {-1};
  const int pv_Rank = 1;
  PyArrayObject *capi_pv_tmp = NULL;
  int capi_pv_intent = 0;
  int jstat = 0;
  static char *capi_kwlist[] = {"date","u",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_ue2pv",\
    capi_kwlist,&date_capi,&u_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable date */
    f2py_success = double_from_pyobj(&date,date_capi,"slalib.sla_ue2pv() 1st argument (date) can't be converted to double");
  if (f2py_success) {
  /* Processing variable u */
  u_Dims[0]=13;
  capi_u_intent |= F2PY_INTENT_OUT|F2PY_INTENT_IN;
  capi_u_tmp = array_from_pyobj(PyArray_DOUBLE,u_Dims,u_Rank,capi_u_intent,u_capi);
  if (capi_u_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `u' of slalib.sla_ue2pv to C/Fortran array" );
  } else {
    u = (double *)(capi_u_tmp->data);

  /* Processing variable pv */
  pv_Dims[0]=6;
  capi_pv_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_pv_tmp = array_from_pyobj(PyArray_DOUBLE,pv_Dims,pv_Rank,capi_pv_intent,Py_None);
  if (capi_pv_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `pv' of slalib.sla_ue2pv to C/Fortran array" );
  } else {
    pv = (double *)(capi_pv_tmp->data);

  /* Processing variable jstat */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&date,u,pv,&jstat);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("NNi",capi_u_tmp,capi_pv_tmp,jstat);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable jstat */
  }  /*if (capi_pv_tmp == NULL) ... else of pv*/
  /* End of cleaning variable pv */
  }  /*if (capi_u_tmp == NULL) ... else of u*/
  /* End of cleaning variable u */
  } /*if (f2py_success) of date*/
  /* End of cleaning variable date */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_ue2pv ******************************/

/********************************* sla_unpcd *********************************/
static char doc_f2py_rout_slalib_sla_unpcd[] = "\
Function signature:\n\
  x,y = sla_unpcd(disco,x,y)\n\
Required arguments:\n"
"  disco : input float\n"
"  x : input float\n"
"  y : input float\n"
"Return objects:\n"
"  x : float\n"
"  y : float";
/* extern void F_FUNC_US(sla_unpcd,SLA_UNPCD)(double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_unpcd(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double disco = 0;
  PyObject *disco_capi = Py_None;
  double x = 0;
  PyObject *x_capi = Py_None;
  double y = 0;
  PyObject *y_capi = Py_None;
  static char *capi_kwlist[] = {"disco","x","y",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_unpcd",\
    capi_kwlist,&disco_capi,&x_capi,&y_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable y */
    f2py_success = double_from_pyobj(&y,y_capi,"slalib.sla_unpcd() 3rd argument (y) can't be converted to double");
  if (f2py_success) {
  /* Processing variable x */
    f2py_success = double_from_pyobj(&x,x_capi,"slalib.sla_unpcd() 2nd argument (x) can't be converted to double");
  if (f2py_success) {
  /* Processing variable disco */
    f2py_success = double_from_pyobj(&disco,disco_capi,"slalib.sla_unpcd() 1st argument (disco) can't be converted to double");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&disco,&x,&y);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",x,y);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of disco*/
  /* End of cleaning variable disco */
  } /*if (f2py_success) of x*/
  /* End of cleaning variable x */
  } /*if (f2py_success) of y*/
  /* End of cleaning variable y */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_unpcd ******************************/

/********************************** sla_v2tp **********************************/
static char doc_f2py_rout_slalib_sla_v2tp[] = "\
Function signature:\n\
  xi,eta,j = sla_v2tp(v,v0)\n\
Required arguments:\n"
"  v : input rank-1 array('f') with bounds (3)\n"
"  v0 : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  xi : float\n"
"  eta : float\n"
"  j : int";
/* extern void F_FUNC_US(sla_v2tp,SLA_V2TP)(float*,float*,float*,float*,int*); */
static PyObject *f2py_rout_slalib_sla_v2tp(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*,float*,int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  float *v0 = NULL;
  npy_intp v0_Dims[1] = {-1};
  const int v0_Rank = 1;
  PyArrayObject *capi_v0_tmp = NULL;
  int capi_v0_intent = 0;
  PyObject *v0_capi = Py_None;
  float xi = 0;
  float eta = 0;
  int j = 0;
  static char *capi_kwlist[] = {"v","v0",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_v2tp",\
    capi_kwlist,&v_capi,&v0_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable v0 */
  v0_Dims[0]=3;
  capi_v0_intent |= F2PY_INTENT_IN;
  capi_v0_tmp = array_from_pyobj(PyArray_FLOAT,v0_Dims,v0_Rank,capi_v0_intent,v0_capi);
  if (capi_v0_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `v0' of slalib.sla_v2tp to C/Fortran array" );
  } else {
    v0 = (float *)(capi_v0_tmp->data);

  /* Processing variable eta */
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_FLOAT,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v' of slalib.sla_v2tp to C/Fortran array" );
  } else {
    v = (float *)(capi_v_tmp->data);

  /* Processing variable xi */
  /* Processing variable j */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(v,v0,&xi,&eta,&j);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("ffi",xi,eta,j);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable j */
  /* End of cleaning variable xi */
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  /* End of cleaning variable eta */
  if((PyObject *)capi_v0_tmp!=v0_capi) {
    Py_XDECREF(capi_v0_tmp); }
  }  /*if (capi_v0_tmp == NULL) ... else of v0*/
  /* End of cleaning variable v0 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_v2tp ******************************/

/********************************** sla_vdv **********************************/
static char doc_f2py_rout_slalib_sla_vdv[] = "\
Function signature:\n\
  sla_vdv = sla_vdv(va,vb)\n\
Required arguments:\n"
"  va : input rank-1 array('f') with bounds (3)\n"
"  vb : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  sla_vdv : float";
/* extern void F_WRAPPEDFUNC_US(sla_vdv,SLA_VDV)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_vdv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float sla_vdv = 0;
  float *va = NULL;
  npy_intp va_Dims[1] = {-1};
  const int va_Rank = 1;
  PyArrayObject *capi_va_tmp = NULL;
  int capi_va_intent = 0;
  PyObject *va_capi = Py_None;
  float *vb = NULL;
  npy_intp vb_Dims[1] = {-1};
  const int vb_Rank = 1;
  PyArrayObject *capi_vb_tmp = NULL;
  int capi_vb_intent = 0;
  PyObject *vb_capi = Py_None;
  static char *capi_kwlist[] = {"va","vb",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_vdv",\
    capi_kwlist,&va_capi,&vb_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable va */
  va_Dims[0]=3;
  capi_va_intent |= F2PY_INTENT_IN;
  capi_va_tmp = array_from_pyobj(PyArray_FLOAT,va_Dims,va_Rank,capi_va_intent,va_capi);
  if (capi_va_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `va' of slalib.sla_vdv to C/Fortran array" );
  } else {
    va = (float *)(capi_va_tmp->data);

  /* Processing variable vb */
  vb_Dims[0]=3;
  capi_vb_intent |= F2PY_INTENT_IN;
  capi_vb_tmp = array_from_pyobj(PyArray_FLOAT,vb_Dims,vb_Rank,capi_vb_intent,vb_capi);
  if (capi_vb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `vb' of slalib.sla_vdv to C/Fortran array" );
  } else {
    vb = (float *)(capi_vb_tmp->data);

  /* Processing variable sla_vdv */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_vdv,va,vb);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("f",sla_vdv);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_vdv */
  if((PyObject *)capi_vb_tmp!=vb_capi) {
    Py_XDECREF(capi_vb_tmp); }
  }  /*if (capi_vb_tmp == NULL) ... else of vb*/
  /* End of cleaning variable vb */
  if((PyObject *)capi_va_tmp!=va_capi) {
    Py_XDECREF(capi_va_tmp); }
  }  /*if (capi_va_tmp == NULL) ... else of va*/
  /* End of cleaning variable va */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_vdv *******************************/

/********************************** sla_veri **********************************/
static char doc_f2py_rout_slalib_sla_veri[] = "\
Function signature:\n\
  sla_veri = sla_veri()\n\
Return objects:\n"
"  sla_veri : int";
/* extern void F_WRAPPEDFUNC_US(sla_veri,SLA_VERI)(int*); */
static PyObject *f2py_rout_slalib_sla_veri(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(int*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  int sla_veri = 0;
  static char *capi_kwlist[] = {NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "|:slalib.sla_veri",\
    capi_kwlist))
    return NULL;
/*frompyobj*/
  /* Processing variable sla_veri */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_veri);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("i",sla_veri);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_veri */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_veri ******************************/

/*********************************** sla_vn ***********************************/
static char doc_f2py_rout_slalib_sla_vn[] = "\
Function signature:\n\
  uv,vm = sla_vn(v)\n\
Required arguments:\n"
"  v : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  uv : rank-1 array('f') with bounds (3)\n"
"  vm : float";
/* extern void F_FUNC_US(sla_vn,SLA_VN)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_vn(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float *v = NULL;
  npy_intp v_Dims[1] = {-1};
  const int v_Rank = 1;
  PyArrayObject *capi_v_tmp = NULL;
  int capi_v_intent = 0;
  PyObject *v_capi = Py_None;
  float *uv = NULL;
  npy_intp uv_Dims[1] = {-1};
  const int uv_Rank = 1;
  PyArrayObject *capi_uv_tmp = NULL;
  int capi_uv_intent = 0;
  float vm = 0;
  static char *capi_kwlist[] = {"v",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_vn",\
    capi_kwlist,&v_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable uv */
  uv_Dims[0]=3;
  capi_uv_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_uv_tmp = array_from_pyobj(PyArray_FLOAT,uv_Dims,uv_Rank,capi_uv_intent,Py_None);
  if (capi_uv_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `uv' of slalib.sla_vn to C/Fortran array" );
  } else {
    uv = (float *)(capi_uv_tmp->data);

  /* Processing variable vm */
  /* Processing variable v */
  v_Dims[0]=3;
  capi_v_intent |= F2PY_INTENT_IN;
  capi_v_tmp = array_from_pyobj(PyArray_FLOAT,v_Dims,v_Rank,capi_v_intent,v_capi);
  if (capi_v_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `v' of slalib.sla_vn to C/Fortran array" );
  } else {
    v = (float *)(capi_v_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(v,uv,&vm);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("Nf",capi_uv_tmp,vm);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  if((PyObject *)capi_v_tmp!=v_capi) {
    Py_XDECREF(capi_v_tmp); }
  }  /*if (capi_v_tmp == NULL) ... else of v*/
  /* End of cleaning variable v */
  /* End of cleaning variable vm */
  }  /*if (capi_uv_tmp == NULL) ... else of uv*/
  /* End of cleaning variable uv */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_vn *******************************/

/********************************** sla_vxv **********************************/
static char doc_f2py_rout_slalib_sla_vxv[] = "\
Function signature:\n\
  vc = sla_vxv(va,vb)\n\
Required arguments:\n"
"  va : input rank-1 array('f') with bounds (3)\n"
"  vb : input rank-1 array('f') with bounds (3)\n"
"Return objects:\n"
"  vc : rank-1 array('f') with bounds (3)";
/* extern void F_FUNC_US(sla_vxv,SLA_VXV)(float*,float*,float*); */
static PyObject *f2py_rout_slalib_sla_vxv(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*,float*,float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float *va = NULL;
  npy_intp va_Dims[1] = {-1};
  const int va_Rank = 1;
  PyArrayObject *capi_va_tmp = NULL;
  int capi_va_intent = 0;
  PyObject *va_capi = Py_None;
  float *vb = NULL;
  npy_intp vb_Dims[1] = {-1};
  const int vb_Rank = 1;
  PyArrayObject *capi_vb_tmp = NULL;
  int capi_vb_intent = 0;
  PyObject *vb_capi = Py_None;
  float *vc = NULL;
  npy_intp vc_Dims[1] = {-1};
  const int vc_Rank = 1;
  PyArrayObject *capi_vc_tmp = NULL;
  int capi_vc_intent = 0;
  static char *capi_kwlist[] = {"va","vb",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OO|:slalib.sla_vxv",\
    capi_kwlist,&va_capi,&vb_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable va */
  va_Dims[0]=3;
  capi_va_intent |= F2PY_INTENT_IN;
  capi_va_tmp = array_from_pyobj(PyArray_FLOAT,va_Dims,va_Rank,capi_va_intent,va_capi);
  if (capi_va_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 1st argument `va' of slalib.sla_vxv to C/Fortran array" );
  } else {
    va = (float *)(capi_va_tmp->data);

  /* Processing variable vb */
  vb_Dims[0]=3;
  capi_vb_intent |= F2PY_INTENT_IN;
  capi_vb_tmp = array_from_pyobj(PyArray_FLOAT,vb_Dims,vb_Rank,capi_vb_intent,vb_capi);
  if (capi_vb_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 2nd argument `vb' of slalib.sla_vxv to C/Fortran array" );
  } else {
    vb = (float *)(capi_vb_tmp->data);

  /* Processing variable vc */
  vc_Dims[0]=3;
  capi_vc_intent |= F2PY_INTENT_HIDE|F2PY_INTENT_OUT;
  capi_vc_tmp = array_from_pyobj(PyArray_FLOAT,vc_Dims,vc_Rank,capi_vc_intent,Py_None);
  if (capi_vc_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting hidden `vc' of slalib.sla_vxv to C/Fortran array" );
  } else {
    vc = (float *)(capi_vc_tmp->data);

/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(va,vb,vc);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("N",capi_vc_tmp);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  }  /*if (capi_vc_tmp == NULL) ... else of vc*/
  /* End of cleaning variable vc */
  if((PyObject *)capi_vb_tmp!=vb_capi) {
    Py_XDECREF(capi_vb_tmp); }
  }  /*if (capi_vb_tmp == NULL) ... else of vb*/
  /* End of cleaning variable vb */
  if((PyObject *)capi_va_tmp!=va_capi) {
    Py_XDECREF(capi_va_tmp); }
  }  /*if (capi_va_tmp == NULL) ... else of va*/
  /* End of cleaning variable va */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_vxv *******************************/

/********************************** sla_wait **********************************/
static char doc_f2py_rout_slalib_sla_wait[] = "\
Function signature:\n\
  sla_wait(delay)\n\
Required arguments:\n"
"  delay : input float";
/* extern void F_FUNC_US(sla_wait,SLA_WAIT)(float*); */
static PyObject *f2py_rout_slalib_sla_wait(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(float*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  float delay = 0;
  PyObject *delay_capi = Py_None;
  static char *capi_kwlist[] = {"delay",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "O|:slalib.sla_wait",\
    capi_kwlist,&delay_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable delay */
    f2py_success = float_from_pyobj(&delay,delay_capi,"slalib.sla_wait() 1st argument (delay) can't be converted to float");
  if (f2py_success) {
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&delay);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("");
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  } /*if (f2py_success) of delay*/
  /* End of cleaning variable delay */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_wait ******************************/

/********************************* sla_xy2xy *********************************/
static char doc_f2py_rout_slalib_sla_xy2xy[] = "\
Function signature:\n\
  x2,y2 = sla_xy2xy(x1,y1,coeffs)\n\
Required arguments:\n"
"  x1 : input float\n"
"  y1 : input float\n"
"  coeffs : input rank-1 array('d') with bounds (6)\n"
"Return objects:\n"
"  x2 : float\n"
"  y2 : float";
/* extern void F_FUNC_US(sla_xy2xy,SLA_XY2XY)(double*,double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_xy2xy(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double x1 = 0;
  PyObject *x1_capi = Py_None;
  double y1 = 0;
  PyObject *y1_capi = Py_None;
  double *coeffs = NULL;
  npy_intp coeffs_Dims[1] = {-1};
  const int coeffs_Rank = 1;
  PyArrayObject *capi_coeffs_tmp = NULL;
  int capi_coeffs_intent = 0;
  PyObject *coeffs_capi = Py_None;
  double x2 = 0;
  double y2 = 0;
  static char *capi_kwlist[] = {"x1","y1","coeffs",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_xy2xy",\
    capi_kwlist,&x1_capi,&y1_capi,&coeffs_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable y1 */
    f2py_success = double_from_pyobj(&y1,y1_capi,"slalib.sla_xy2xy() 2nd argument (y1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable coeffs */
  coeffs_Dims[0]=6;
  capi_coeffs_intent |= F2PY_INTENT_IN;
  capi_coeffs_tmp = array_from_pyobj(PyArray_DOUBLE,coeffs_Dims,coeffs_Rank,capi_coeffs_intent,coeffs_capi);
  if (capi_coeffs_tmp == NULL) {
    if (!PyErr_Occurred())
      PyErr_SetString(slalib_error,"failed in converting 3rd argument `coeffs' of slalib.sla_xy2xy to C/Fortran array" );
  } else {
    coeffs = (double *)(capi_coeffs_tmp->data);

  /* Processing variable x1 */
    f2py_success = double_from_pyobj(&x1,x1_capi,"slalib.sla_xy2xy() 1st argument (x1) can't be converted to double");
  if (f2py_success) {
  /* Processing variable y2 */
  /* Processing variable x2 */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
        (*f2py_func)(&x1,&y1,coeffs,&x2,&y2);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("dd",x2,y2);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable x2 */
  /* End of cleaning variable y2 */
  } /*if (f2py_success) of x1*/
  /* End of cleaning variable x1 */
  if((PyObject *)capi_coeffs_tmp!=coeffs_capi) {
    Py_XDECREF(capi_coeffs_tmp); }
  }  /*if (capi_coeffs_tmp == NULL) ... else of coeffs*/
  /* End of cleaning variable coeffs */
  } /*if (f2py_success) of y1*/
  /* End of cleaning variable y1 */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/****************************** end of sla_xy2xy ******************************/

/*********************************** sla_zd ***********************************/
static char doc_f2py_rout_slalib_sla_zd[] = "\
Function signature:\n\
  sla_zd = sla_zd(ha,dec,phi)\n\
Required arguments:\n"
"  ha : input float\n"
"  dec : input float\n"
"  phi : input float\n"
"Return objects:\n"
"  sla_zd : float";
/* extern void F_WRAPPEDFUNC_US(sla_zd,SLA_ZD)(double*,double*,double*,double*); */
static PyObject *f2py_rout_slalib_sla_zd(const PyObject *capi_self,
                           PyObject *capi_args,
                           PyObject *capi_keywds,
                           void (*f2py_func)(double*,double*,double*,double*)) {
  PyObject * volatile capi_buildvalue = NULL;
  volatile int f2py_success = 1;
/*decl*/

  double sla_zd = 0;
  double ha = 0;
  PyObject *ha_capi = Py_None;
  double dec = 0;
  PyObject *dec_capi = Py_None;
  double phi = 0;
  PyObject *phi_capi = Py_None;
  static char *capi_kwlist[] = {"ha","dec","phi",NULL};

/*routdebugenter*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_clock();
#endif
  if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\
    "OOO|:slalib.sla_zd",\
    capi_kwlist,&ha_capi,&dec_capi,&phi_capi))
    return NULL;
/*frompyobj*/
  /* Processing variable phi */
    f2py_success = double_from_pyobj(&phi,phi_capi,"slalib.sla_zd() 3rd argument (phi) can't be converted to double");
  if (f2py_success) {
  /* Processing variable ha */
    f2py_success = double_from_pyobj(&ha,ha_capi,"slalib.sla_zd() 1st argument (ha) can't be converted to double");
  if (f2py_success) {
  /* Processing variable dec */
    f2py_success = double_from_pyobj(&dec,dec_capi,"slalib.sla_zd() 2nd argument (dec) can't be converted to double");
  if (f2py_success) {
  /* Processing variable sla_zd */
/*end of frompyobj*/
#ifdef F2PY_REPORT_ATEXIT
f2py_start_call_clock();
#endif
/*callfortranroutine*/
  (*f2py_func)(&sla_zd,&ha,&dec,&phi);
if (PyErr_Occurred())
  f2py_success = 0;
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_call_clock();
#endif
/*end of callfortranroutine*/
    if (f2py_success) {
/*pyobjfrom*/
/*end of pyobjfrom*/
    CFUNCSMESS("Building return value.\n");
    capi_buildvalue = Py_BuildValue("d",sla_zd);
/*closepyobjfrom*/
/*end of closepyobjfrom*/
    } /*if (f2py_success) after callfortranroutine*/
/*cleanupfrompyobj*/
  /* End of cleaning variable sla_zd */
  } /*if (f2py_success) of dec*/
  /* End of cleaning variable dec */
  } /*if (f2py_success) of ha*/
  /* End of cleaning variable ha */
  } /*if (f2py_success) of phi*/
  /* End of cleaning variable phi */
/*end of cleanupfrompyobj*/
  if (capi_buildvalue == NULL) {
/*routdebugfailure*/
  } else {
/*routdebugleave*/
  }
  CFUNCSMESS("Freeing memory.\n");
/*freemem*/
#ifdef F2PY_REPORT_ATEXIT
f2py_stop_clock();
#endif
  return capi_buildvalue;
}
/******************************* end of sla_zd *******************************/
/*eof body*/

/******************* See f2py2e/f90mod_rules.py: buildhooks *******************/
/*need_f90modhooks*/

/************** See f2py2e/rules.py: module_rules['modulebody'] **************/

/******************* See f2py2e/common_rules.py: buildhooks *******************/

/*need_commonhooks*/

/**************************** See f2py2e/rules.py ****************************/

static FortranDataDef f2py_routine_defs[] = {
  {"sla_addet",-1,{{-1}},0,(char *)F_FUNC_US(sla_addet,SLA_ADDET),(f2py_init_func)f2py_rout_slalib_sla_addet,doc_f2py_rout_slalib_sla_addet},
  {"sla_afin",-1,{{-1}},0,(char *)F_FUNC_US(sla_afin,SLA_AFIN),(f2py_init_func)f2py_rout_slalib_sla_afin,doc_f2py_rout_slalib_sla_afin},
  {"sla_airmas",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_airmas,SLA_AIRMAS),(f2py_init_func)f2py_rout_slalib_sla_airmas,doc_f2py_rout_slalib_sla_airmas},
  {"sla_altaz",-1,{{-1}},0,(char *)F_FUNC_US(sla_altaz,SLA_ALTAZ),(f2py_init_func)f2py_rout_slalib_sla_altaz,doc_f2py_rout_slalib_sla_altaz},
  {"sla_amp",-1,{{-1}},0,(char *)F_FUNC_US(sla_amp,SLA_AMP),(f2py_init_func)f2py_rout_slalib_sla_amp,doc_f2py_rout_slalib_sla_amp},
  {"sla_ampqk",-1,{{-1}},0,(char *)F_FUNC_US(sla_ampqk,SLA_AMPQK),(f2py_init_func)f2py_rout_slalib_sla_ampqk,doc_f2py_rout_slalib_sla_ampqk},
  {"sla_aop",-1,{{-1}},0,(char *)F_FUNC_US(sla_aop,SLA_AOP),(f2py_init_func)f2py_rout_slalib_sla_aop,doc_f2py_rout_slalib_sla_aop},
  {"sla_aoppa",-1,{{-1}},0,(char *)F_FUNC_US(sla_aoppa,SLA_AOPPA),(f2py_init_func)f2py_rout_slalib_sla_aoppa,doc_f2py_rout_slalib_sla_aoppa},
  {"sla_aoppat",-1,{{-1}},0,(char *)F_FUNC_US(sla_aoppat,SLA_AOPPAT),(f2py_init_func)f2py_rout_slalib_sla_aoppat,doc_f2py_rout_slalib_sla_aoppat},
  {"sla_aopqk",-1,{{-1}},0,(char *)F_FUNC_US(sla_aopqk,SLA_AOPQK),(f2py_init_func)f2py_rout_slalib_sla_aopqk,doc_f2py_rout_slalib_sla_aopqk},
  {"sla_atmdsp",-1,{{-1}},0,(char *)F_FUNC_US(sla_atmdsp,SLA_ATMDSP),(f2py_init_func)f2py_rout_slalib_sla_atmdsp,doc_f2py_rout_slalib_sla_atmdsp},
  {"sla__atms",-1,{{-1}},0,(char *)F_FUNC_US(sla__atms,SLA__ATMS),(f2py_init_func)f2py_rout_slalib_sla__atms,doc_f2py_rout_slalib_sla__atms},
  {"sla__atmt",-1,{{-1}},0,(char *)F_FUNC_US(sla__atmt,SLA__ATMT),(f2py_init_func)f2py_rout_slalib_sla__atmt,doc_f2py_rout_slalib_sla__atmt},
  {"sla_av2m",-1,{{-1}},0,(char *)F_FUNC_US(sla_av2m,SLA_AV2M),(f2py_init_func)f2py_rout_slalib_sla_av2m,doc_f2py_rout_slalib_sla_av2m},
  {"sla_bear",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_bear,SLA_BEAR),(f2py_init_func)f2py_rout_slalib_sla_bear,doc_f2py_rout_slalib_sla_bear},
  {"sla_caf2r",-1,{{-1}},0,(char *)F_FUNC_US(sla_caf2r,SLA_CAF2R),(f2py_init_func)f2py_rout_slalib_sla_caf2r,doc_f2py_rout_slalib_sla_caf2r},
  {"sla_caldj",-1,{{-1}},0,(char *)F_FUNC_US(sla_caldj,SLA_CALDJ),(f2py_init_func)f2py_rout_slalib_sla_caldj,doc_f2py_rout_slalib_sla_caldj},
  {"sla_calyd",-1,{{-1}},0,(char *)F_FUNC_US(sla_calyd,SLA_CALYD),(f2py_init_func)f2py_rout_slalib_sla_calyd,doc_f2py_rout_slalib_sla_calyd},
  {"sla_cc2s",-1,{{-1}},0,(char *)F_FUNC_US(sla_cc2s,SLA_CC2S),(f2py_init_func)f2py_rout_slalib_sla_cc2s,doc_f2py_rout_slalib_sla_cc2s},
  {"sla_cc62s",-1,{{-1}},0,(char *)F_FUNC_US(sla_cc62s,SLA_CC62S),(f2py_init_func)f2py_rout_slalib_sla_cc62s,doc_f2py_rout_slalib_sla_cc62s},
  {"sla_cd2tf",-1,{{-1}},0,(char *)F_FUNC_US(sla_cd2tf,SLA_CD2TF),(f2py_init_func)f2py_rout_slalib_sla_cd2tf,doc_f2py_rout_slalib_sla_cd2tf},
  {"sla_cldj",-1,{{-1}},0,(char *)F_FUNC_US(sla_cldj,SLA_CLDJ),(f2py_init_func)f2py_rout_slalib_sla_cldj,doc_f2py_rout_slalib_sla_cldj},
  {"sla_clyd",-1,{{-1}},0,(char *)F_FUNC_US(sla_clyd,SLA_CLYD),(f2py_init_func)f2py_rout_slalib_sla_clyd,doc_f2py_rout_slalib_sla_clyd},
  {"sla_combn",-1,{{-1}},0,(char *)F_FUNC_US(sla_combn,SLA_COMBN),(f2py_init_func)f2py_rout_slalib_sla_combn,doc_f2py_rout_slalib_sla_combn},
  {"sla_cr2af",-1,{{-1}},0,(char *)F_FUNC_US(sla_cr2af,SLA_CR2AF),(f2py_init_func)f2py_rout_slalib_sla_cr2af,doc_f2py_rout_slalib_sla_cr2af},
  {"sla_cr2tf",-1,{{-1}},0,(char *)F_FUNC_US(sla_cr2tf,SLA_CR2TF),(f2py_init_func)f2py_rout_slalib_sla_cr2tf,doc_f2py_rout_slalib_sla_cr2tf},
  {"sla_cs2c6",-1,{{-1}},0,(char *)F_FUNC_US(sla_cs2c6,SLA_CS2C6),(f2py_init_func)f2py_rout_slalib_sla_cs2c6,doc_f2py_rout_slalib_sla_cs2c6},
  {"sla_cs2c",-1,{{-1}},0,(char *)F_FUNC_US(sla_cs2c,SLA_CS2C),(f2py_init_func)f2py_rout_slalib_sla_cs2c,doc_f2py_rout_slalib_sla_cs2c},
  {"sla_ctf2d",-1,{{-1}},0,(char *)F_FUNC_US(sla_ctf2d,SLA_CTF2D),(f2py_init_func)f2py_rout_slalib_sla_ctf2d,doc_f2py_rout_slalib_sla_ctf2d},
  {"sla_ctf2r",-1,{{-1}},0,(char *)F_FUNC_US(sla_ctf2r,SLA_CTF2R),(f2py_init_func)f2py_rout_slalib_sla_ctf2r,doc_f2py_rout_slalib_sla_ctf2r},
  {"sla_daf2r",-1,{{-1}},0,(char *)F_FUNC_US(sla_daf2r,SLA_DAF2R),(f2py_init_func)f2py_rout_slalib_sla_daf2r,doc_f2py_rout_slalib_sla_daf2r},
  {"sla_dafin",-1,{{-1}},0,(char *)F_FUNC_US(sla_dafin,SLA_DAFIN),(f2py_init_func)f2py_rout_slalib_sla_dafin,doc_f2py_rout_slalib_sla_dafin},
  {"sla_dat",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_dat,SLA_DAT),(f2py_init_func)f2py_rout_slalib_sla_dat,doc_f2py_rout_slalib_sla_dat},
  {"sla_dav2m",-1,{{-1}},0,(char *)F_FUNC_US(sla_dav2m,SLA_DAV2M),(f2py_init_func)f2py_rout_slalib_sla_dav2m,doc_f2py_rout_slalib_sla_dav2m},
  {"sla_dbear",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_dbear,SLA_DBEAR),(f2py_init_func)f2py_rout_slalib_sla_dbear,doc_f2py_rout_slalib_sla_dbear},
  {"sla_dbjin",-1,{{-1}},0,(char *)F_FUNC_US(sla_dbjin,SLA_DBJIN),(f2py_init_func)f2py_rout_slalib_sla_dbjin,doc_f2py_rout_slalib_sla_dbjin},
  {"sla_dc62s",-1,{{-1}},0,(char *)F_FUNC_US(sla_dc62s,SLA_DC62S),(f2py_init_func)f2py_rout_slalib_sla_dc62s,doc_f2py_rout_slalib_sla_dc62s},
  {"sla_dcc2s",-1,{{-1}},0,(char *)F_FUNC_US(sla_dcc2s,SLA_DCC2S),(f2py_init_func)f2py_rout_slalib_sla_dcc2s,doc_f2py_rout_slalib_sla_dcc2s},
  {"sla_dcmpf",-1,{{-1}},0,(char *)F_FUNC_US(sla_dcmpf,SLA_DCMPF),(f2py_init_func)f2py_rout_slalib_sla_dcmpf,doc_f2py_rout_slalib_sla_dcmpf},
  {"sla_dcs2c",-1,{{-1}},0,(char *)F_FUNC_US(sla_dcs2c,SLA_DCS2C),(f2py_init_func)f2py_rout_slalib_sla_dcs2c,doc_f2py_rout_slalib_sla_dcs2c},
  {"sla_dd2tf",-1,{{-1}},0,(char *)F_FUNC_US(sla_dd2tf,SLA_DD2TF),(f2py_init_func)f2py_rout_slalib_sla_dd2tf,doc_f2py_rout_slalib_sla_dd2tf},
  {"sla_de2h",-1,{{-1}},0,(char *)F_FUNC_US(sla_de2h,SLA_DE2H),(f2py_init_func)f2py_rout_slalib_sla_de2h,doc_f2py_rout_slalib_sla_de2h},
  {"sla_deuler",-1,{{-1}},0,(char *)F_FUNC_US(sla_deuler,SLA_DEULER),(f2py_init_func)f2py_rout_slalib_sla_deuler,doc_f2py_rout_slalib_sla_deuler},
  {"sla_dfltin",-1,{{-1}},0,(char *)F_FUNC_US(sla_dfltin,SLA_DFLTIN),(f2py_init_func)f2py_rout_slalib_sla_dfltin,doc_f2py_rout_slalib_sla_dfltin},
  {"sla_dh2e",-1,{{-1}},0,(char *)F_FUNC_US(sla_dh2e,SLA_DH2E),(f2py_init_func)f2py_rout_slalib_sla_dh2e,doc_f2py_rout_slalib_sla_dh2e},
  {"sla_dimxv",-1,{{-1}},0,(char *)F_FUNC_US(sla_dimxv,SLA_DIMXV),(f2py_init_func)f2py_rout_slalib_sla_dimxv,doc_f2py_rout_slalib_sla_dimxv},
  {"sla_djcal",-1,{{-1}},0,(char *)F_FUNC_US(sla_djcal,SLA_DJCAL),(f2py_init_func)f2py_rout_slalib_sla_djcal,doc_f2py_rout_slalib_sla_djcal},
  {"sla_djcl",-1,{{-1}},0,(char *)F_FUNC_US(sla_djcl,SLA_DJCL),(f2py_init_func)f2py_rout_slalib_sla_djcl,doc_f2py_rout_slalib_sla_djcl},
  {"sla_dm2av",-1,{{-1}},0,(char *)F_FUNC_US(sla_dm2av,SLA_DM2AV),(f2py_init_func)f2py_rout_slalib_sla_dm2av,doc_f2py_rout_slalib_sla_dm2av},
  {"sla_dmat",-1,{{-1}},0,(char *)F_FUNC_US(sla_dmat,SLA_DMAT),(f2py_init_func)f2py_rout_slalib_sla_dmat,doc_f2py_rout_slalib_sla_dmat},
  {"sla_dmoon",-1,{{-1}},0,(char *)F_FUNC_US(sla_dmoon,SLA_DMOON),(f2py_init_func)f2py_rout_slalib_sla_dmoon,doc_f2py_rout_slalib_sla_dmoon},
  {"sla_dmxm",-1,{{-1}},0,(char *)F_FUNC_US(sla_dmxm,SLA_DMXM),(f2py_init_func)f2py_rout_slalib_sla_dmxm,doc_f2py_rout_slalib_sla_dmxm},
  {"sla_dmxv",-1,{{-1}},0,(char *)F_FUNC_US(sla_dmxv,SLA_DMXV),(f2py_init_func)f2py_rout_slalib_sla_dmxv,doc_f2py_rout_slalib_sla_dmxv},
  {"sla_dpav",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_dpav,SLA_DPAV),(f2py_init_func)f2py_rout_slalib_sla_dpav,doc_f2py_rout_slalib_sla_dpav},
  {"sla_dr2af",-1,{{-1}},0,(char *)F_FUNC_US(sla_dr2af,SLA_DR2AF),(f2py_init_func)f2py_rout_slalib_sla_dr2af,doc_f2py_rout_slalib_sla_dr2af},
  {"sla_dr2tf",-1,{{-1}},0,(char *)F_FUNC_US(sla_dr2tf,SLA_DR2TF),(f2py_init_func)f2py_rout_slalib_sla_dr2tf,doc_f2py_rout_slalib_sla_dr2tf},
  {"sla_drange",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_drange,SLA_DRANGE),(f2py_init_func)f2py_rout_slalib_sla_drange,doc_f2py_rout_slalib_sla_drange},
  {"sla_dranrm",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_dranrm,SLA_DRANRM),(f2py_init_func)f2py_rout_slalib_sla_dranrm,doc_f2py_rout_slalib_sla_dranrm},
  {"sla_ds2c6",-1,{{-1}},0,(char *)F_FUNC_US(sla_ds2c6,SLA_DS2C6),(f2py_init_func)f2py_rout_slalib_sla_ds2c6,doc_f2py_rout_slalib_sla_ds2c6},
  {"sla_ds2tp",-1,{{-1}},0,(char *)F_FUNC_US(sla_ds2tp,SLA_DS2TP),(f2py_init_func)f2py_rout_slalib_sla_ds2tp,doc_f2py_rout_slalib_sla_ds2tp},
  {"sla_dsep",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_dsep,SLA_DSEP),(f2py_init_func)f2py_rout_slalib_sla_dsep,doc_f2py_rout_slalib_sla_dsep},
  {"sla_dsepv",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_dsepv,SLA_DSEPV),(f2py_init_func)f2py_rout_slalib_sla_dsepv,doc_f2py_rout_slalib_sla_dsepv},
  {"sla_dt",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_dt,SLA_DT),(f2py_init_func)f2py_rout_slalib_sla_dt,doc_f2py_rout_slalib_sla_dt},
  {"sla_dtf2d",-1,{{-1}},0,(char *)F_FUNC_US(sla_dtf2d,SLA_DTF2D),(f2py_init_func)f2py_rout_slalib_sla_dtf2d,doc_f2py_rout_slalib_sla_dtf2d},
  {"sla_dtf2r",-1,{{-1}},0,(char *)F_FUNC_US(sla_dtf2r,SLA_DTF2R),(f2py_init_func)f2py_rout_slalib_sla_dtf2r,doc_f2py_rout_slalib_sla_dtf2r},
  {"sla_dtp2s",-1,{{-1}},0,(char *)F_FUNC_US(sla_dtp2s,SLA_DTP2S),(f2py_init_func)f2py_rout_slalib_sla_dtp2s,doc_f2py_rout_slalib_sla_dtp2s},
  {"sla_dtp2v",-1,{{-1}},0,(char *)F_FUNC_US(sla_dtp2v,SLA_DTP2V),(f2py_init_func)f2py_rout_slalib_sla_dtp2v,doc_f2py_rout_slalib_sla_dtp2v},
  {"sla_dtps2c",-1,{{-1}},0,(char *)F_FUNC_US(sla_dtps2c,SLA_DTPS2C),(f2py_init_func)f2py_rout_slalib_sla_dtps2c,doc_f2py_rout_slalib_sla_dtps2c},
  {"sla_dtpv2c",-1,{{-1}},0,(char *)F_FUNC_US(sla_dtpv2c,SLA_DTPV2C),(f2py_init_func)f2py_rout_slalib_sla_dtpv2c,doc_f2py_rout_slalib_sla_dtpv2c},
  {"sla_dtt",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_dtt,SLA_DTT),(f2py_init_func)f2py_rout_slalib_sla_dtt,doc_f2py_rout_slalib_sla_dtt},
  {"sla_dv2tp",-1,{{-1}},0,(char *)F_FUNC_US(sla_dv2tp,SLA_DV2TP),(f2py_init_func)f2py_rout_slalib_sla_dv2tp,doc_f2py_rout_slalib_sla_dv2tp},
  {"sla_dvdv",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_dvdv,SLA_DVDV),(f2py_init_func)f2py_rout_slalib_sla_dvdv,doc_f2py_rout_slalib_sla_dvdv},
  {"sla_dvn",-1,{{-1}},0,(char *)F_FUNC_US(sla_dvn,SLA_DVN),(f2py_init_func)f2py_rout_slalib_sla_dvn,doc_f2py_rout_slalib_sla_dvn},
  {"sla_dvxv",-1,{{-1}},0,(char *)F_FUNC_US(sla_dvxv,SLA_DVXV),(f2py_init_func)f2py_rout_slalib_sla_dvxv,doc_f2py_rout_slalib_sla_dvxv},
  {"sla_e2h",-1,{{-1}},0,(char *)F_FUNC_US(sla_e2h,SLA_E2H),(f2py_init_func)f2py_rout_slalib_sla_e2h,doc_f2py_rout_slalib_sla_e2h},
  {"sla_earth",-1,{{-1}},0,(char *)F_FUNC_US(sla_earth,SLA_EARTH),(f2py_init_func)f2py_rout_slalib_sla_earth,doc_f2py_rout_slalib_sla_earth},
  {"sla_ecleq",-1,{{-1}},0,(char *)F_FUNC_US(sla_ecleq,SLA_ECLEQ),(f2py_init_func)f2py_rout_slalib_sla_ecleq,doc_f2py_rout_slalib_sla_ecleq},
  {"sla_ecmat",-1,{{-1}},0,(char *)F_FUNC_US(sla_ecmat,SLA_ECMAT),(f2py_init_func)f2py_rout_slalib_sla_ecmat,doc_f2py_rout_slalib_sla_ecmat},
  {"sla_ecor",-1,{{-1}},0,(char *)F_FUNC_US(sla_ecor,SLA_ECOR),(f2py_init_func)f2py_rout_slalib_sla_ecor,doc_f2py_rout_slalib_sla_ecor},
  {"sla_eg50",-1,{{-1}},0,(char *)F_FUNC_US(sla_eg50,SLA_EG50),(f2py_init_func)f2py_rout_slalib_sla_eg50,doc_f2py_rout_slalib_sla_eg50},
  {"sla_el2ue",-1,{{-1}},0,(char *)F_FUNC_US(sla_el2ue,SLA_EL2UE),(f2py_init_func)f2py_rout_slalib_sla_el2ue,doc_f2py_rout_slalib_sla_el2ue},
  {"sla_epb2d",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_epb2d,SLA_EPB2D),(f2py_init_func)f2py_rout_slalib_sla_epb2d,doc_f2py_rout_slalib_sla_epb2d},
  {"sla_epb",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_epb,SLA_EPB),(f2py_init_func)f2py_rout_slalib_sla_epb,doc_f2py_rout_slalib_sla_epb},
  {"sla_epco",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_epco,SLA_EPCO),(f2py_init_func)f2py_rout_slalib_sla_epco,doc_f2py_rout_slalib_sla_epco},
  {"sla_epj2d",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_epj2d,SLA_EPJ2D),(f2py_init_func)f2py_rout_slalib_sla_epj2d,doc_f2py_rout_slalib_sla_epj2d},
  {"sla_epj",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_epj,SLA_EPJ),(f2py_init_func)f2py_rout_slalib_sla_epj,doc_f2py_rout_slalib_sla_epj},
  {"sla_epv",-1,{{-1}},0,(char *)F_FUNC_US(sla_epv,SLA_EPV),(f2py_init_func)f2py_rout_slalib_sla_epv,doc_f2py_rout_slalib_sla_epv},
  {"sla_eqecl",-1,{{-1}},0,(char *)F_FUNC_US(sla_eqecl,SLA_EQECL),(f2py_init_func)f2py_rout_slalib_sla_eqecl,doc_f2py_rout_slalib_sla_eqecl},
  {"sla_eqeqx",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_eqeqx,SLA_EQEQX),(f2py_init_func)f2py_rout_slalib_sla_eqeqx,doc_f2py_rout_slalib_sla_eqeqx},
  {"sla_eqgal",-1,{{-1}},0,(char *)F_FUNC_US(sla_eqgal,SLA_EQGAL),(f2py_init_func)f2py_rout_slalib_sla_eqgal,doc_f2py_rout_slalib_sla_eqgal},
  {"sla_etrms",-1,{{-1}},0,(char *)F_FUNC_US(sla_etrms,SLA_ETRMS),(f2py_init_func)f2py_rout_slalib_sla_etrms,doc_f2py_rout_slalib_sla_etrms},
  {"sla_euler",-1,{{-1}},0,(char *)F_FUNC_US(sla_euler,SLA_EULER),(f2py_init_func)f2py_rout_slalib_sla_euler,doc_f2py_rout_slalib_sla_euler},
  {"sla_evp",-1,{{-1}},0,(char *)F_FUNC_US(sla_evp,SLA_EVP),(f2py_init_func)f2py_rout_slalib_sla_evp,doc_f2py_rout_slalib_sla_evp},
  {"sla_fitxy",-1,{{-1}},0,(char *)F_FUNC_US(sla_fitxy,SLA_FITXY),(f2py_init_func)f2py_rout_slalib_sla_fitxy,doc_f2py_rout_slalib_sla_fitxy},
  {"sla_fk425",-1,{{-1}},0,(char *)F_FUNC_US(sla_fk425,SLA_FK425),(f2py_init_func)f2py_rout_slalib_sla_fk425,doc_f2py_rout_slalib_sla_fk425},
  {"sla_fk45z",-1,{{-1}},0,(char *)F_FUNC_US(sla_fk45z,SLA_FK45Z),(f2py_init_func)f2py_rout_slalib_sla_fk45z,doc_f2py_rout_slalib_sla_fk45z},
  {"sla_fk524",-1,{{-1}},0,(char *)F_FUNC_US(sla_fk524,SLA_FK524),(f2py_init_func)f2py_rout_slalib_sla_fk524,doc_f2py_rout_slalib_sla_fk524},
  {"sla_fk52h",-1,{{-1}},0,(char *)F_FUNC_US(sla_fk52h,SLA_FK52H),(f2py_init_func)f2py_rout_slalib_sla_fk52h,doc_f2py_rout_slalib_sla_fk52h},
  {"sla_fk54z",-1,{{-1}},0,(char *)F_FUNC_US(sla_fk54z,SLA_FK54Z),(f2py_init_func)f2py_rout_slalib_sla_fk54z,doc_f2py_rout_slalib_sla_fk54z},
  {"sla_fk5hz",-1,{{-1}},0,(char *)F_FUNC_US(sla_fk5hz,SLA_FK5HZ),(f2py_init_func)f2py_rout_slalib_sla_fk5hz,doc_f2py_rout_slalib_sla_fk5hz},
  {"sla_flotin",-1,{{-1}},0,(char *)F_FUNC_US(sla_flotin,SLA_FLOTIN),(f2py_init_func)f2py_rout_slalib_sla_flotin,doc_f2py_rout_slalib_sla_flotin},
  {"sla_galeq",-1,{{-1}},0,(char *)F_FUNC_US(sla_galeq,SLA_GALEQ),(f2py_init_func)f2py_rout_slalib_sla_galeq,doc_f2py_rout_slalib_sla_galeq},
  {"sla_galsup",-1,{{-1}},0,(char *)F_FUNC_US(sla_galsup,SLA_GALSUP),(f2py_init_func)f2py_rout_slalib_sla_galsup,doc_f2py_rout_slalib_sla_galsup},
  {"sla_ge50",-1,{{-1}},0,(char *)F_FUNC_US(sla_ge50,SLA_GE50),(f2py_init_func)f2py_rout_slalib_sla_ge50,doc_f2py_rout_slalib_sla_ge50},
  {"sla_geoc",-1,{{-1}},0,(char *)F_FUNC_US(sla_geoc,SLA_GEOC),(f2py_init_func)f2py_rout_slalib_sla_geoc,doc_f2py_rout_slalib_sla_geoc},
  {"sla_gmsta",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_gmsta,SLA_GMSTA),(f2py_init_func)f2py_rout_slalib_sla_gmsta,doc_f2py_rout_slalib_sla_gmsta},
  {"sla_gmst",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_gmst,SLA_GMST),(f2py_init_func)f2py_rout_slalib_sla_gmst,doc_f2py_rout_slalib_sla_gmst},
  {"sla_h2e",-1,{{-1}},0,(char *)F_FUNC_US(sla_h2e,SLA_H2E),(f2py_init_func)f2py_rout_slalib_sla_h2e,doc_f2py_rout_slalib_sla_h2e},
  {"sla_h2fk5",-1,{{-1}},0,(char *)F_FUNC_US(sla_h2fk5,SLA_H2FK5),(f2py_init_func)f2py_rout_slalib_sla_h2fk5,doc_f2py_rout_slalib_sla_h2fk5},
  {"sla_hfk5z",-1,{{-1}},0,(char *)F_FUNC_US(sla_hfk5z,SLA_HFK5Z),(f2py_init_func)f2py_rout_slalib_sla_hfk5z,doc_f2py_rout_slalib_sla_hfk5z},
  {"sla__idchf",-1,{{-1}},0,(char *)F_FUNC_US(sla__idchf,SLA__IDCHF),(f2py_init_func)f2py_rout_slalib_sla__idchf,doc_f2py_rout_slalib_sla__idchf},
  {"sla__idchi",-1,{{-1}},0,(char *)F_FUNC_US(sla__idchi,SLA__IDCHI),(f2py_init_func)f2py_rout_slalib_sla__idchi,doc_f2py_rout_slalib_sla__idchi},
  {"sla_imxv",-1,{{-1}},0,(char *)F_FUNC_US(sla_imxv,SLA_IMXV),(f2py_init_func)f2py_rout_slalib_sla_imxv,doc_f2py_rout_slalib_sla_imxv},
  {"sla_intin",-1,{{-1}},0,(char *)F_FUNC_US(sla_intin,SLA_INTIN),(f2py_init_func)f2py_rout_slalib_sla_intin,doc_f2py_rout_slalib_sla_intin},
  {"sla_invf",-1,{{-1}},0,(char *)F_FUNC_US(sla_invf,SLA_INVF),(f2py_init_func)f2py_rout_slalib_sla_invf,doc_f2py_rout_slalib_sla_invf},
  {"sla_kbj",-1,{{-1}},0,(char *)F_FUNC_US(sla_kbj,SLA_KBJ),(f2py_init_func)f2py_rout_slalib_sla_kbj,doc_f2py_rout_slalib_sla_kbj},
  {"sla_m2av",-1,{{-1}},0,(char *)F_FUNC_US(sla_m2av,SLA_M2AV),(f2py_init_func)f2py_rout_slalib_sla_m2av,doc_f2py_rout_slalib_sla_m2av},
  {"sla_map",-1,{{-1}},0,(char *)F_FUNC_US(sla_map,SLA_MAP),(f2py_init_func)f2py_rout_slalib_sla_map,doc_f2py_rout_slalib_sla_map},
  {"sla_mappa",-1,{{-1}},0,(char *)F_FUNC_US(sla_mappa,SLA_MAPPA),(f2py_init_func)f2py_rout_slalib_sla_mappa,doc_f2py_rout_slalib_sla_mappa},
  {"sla_mapqk",-1,{{-1}},0,(char *)F_FUNC_US(sla_mapqk,SLA_MAPQK),(f2py_init_func)f2py_rout_slalib_sla_mapqk,doc_f2py_rout_slalib_sla_mapqk},
  {"sla_mapqkz",-1,{{-1}},0,(char *)F_FUNC_US(sla_mapqkz,SLA_MAPQKZ),(f2py_init_func)f2py_rout_slalib_sla_mapqkz,doc_f2py_rout_slalib_sla_mapqkz},
  {"sla_moon",-1,{{-1}},0,(char *)F_FUNC_US(sla_moon,SLA_MOON),(f2py_init_func)f2py_rout_slalib_sla_moon,doc_f2py_rout_slalib_sla_moon},
  {"sla_mxm",-1,{{-1}},0,(char *)F_FUNC_US(sla_mxm,SLA_MXM),(f2py_init_func)f2py_rout_slalib_sla_mxm,doc_f2py_rout_slalib_sla_mxm},
  {"sla_mxv",-1,{{-1}},0,(char *)F_FUNC_US(sla_mxv,SLA_MXV),(f2py_init_func)f2py_rout_slalib_sla_mxv,doc_f2py_rout_slalib_sla_mxv},
  {"sla_nutc80",-1,{{-1}},0,(char *)F_FUNC_US(sla_nutc80,SLA_NUTC80),(f2py_init_func)f2py_rout_slalib_sla_nutc80,doc_f2py_rout_slalib_sla_nutc80},
  {"sla_nutc",-1,{{-1}},0,(char *)F_FUNC_US(sla_nutc,SLA_NUTC),(f2py_init_func)f2py_rout_slalib_sla_nutc,doc_f2py_rout_slalib_sla_nutc},
  {"sla_nut",-1,{{-1}},0,(char *)F_FUNC_US(sla_nut,SLA_NUT),(f2py_init_func)f2py_rout_slalib_sla_nut,doc_f2py_rout_slalib_sla_nut},
  {"sla_oap",-1,{{-1}},0,(char *)F_FUNC_US(sla_oap,SLA_OAP),(f2py_init_func)f2py_rout_slalib_sla_oap,doc_f2py_rout_slalib_sla_oap},
  {"sla_oapqk",-1,{{-1}},0,(char *)F_FUNC_US(sla_oapqk,SLA_OAPQK),(f2py_init_func)f2py_rout_slalib_sla_oapqk,doc_f2py_rout_slalib_sla_oapqk},
  {"sla_obs",-1,{{-1}},0,(char *)F_FUNC_US(sla_obs,SLA_OBS),(f2py_init_func)f2py_rout_slalib_sla_obs,doc_f2py_rout_slalib_sla_obs},
  {"sla_pa",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_pa,SLA_PA),(f2py_init_func)f2py_rout_slalib_sla_pa,doc_f2py_rout_slalib_sla_pa},
  {"sla_pav",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_pav,SLA_PAV),(f2py_init_func)f2py_rout_slalib_sla_pav,doc_f2py_rout_slalib_sla_pav},
  {"sla_pcd",-1,{{-1}},0,(char *)F_FUNC_US(sla_pcd,SLA_PCD),(f2py_init_func)f2py_rout_slalib_sla_pcd,doc_f2py_rout_slalib_sla_pcd},
  {"sla_pda2h",-1,{{-1}},0,(char *)F_FUNC_US(sla_pda2h,SLA_PDA2H),(f2py_init_func)f2py_rout_slalib_sla_pda2h,doc_f2py_rout_slalib_sla_pda2h},
  {"sla_pdq2h",-1,{{-1}},0,(char *)F_FUNC_US(sla_pdq2h,SLA_PDQ2H),(f2py_init_func)f2py_rout_slalib_sla_pdq2h,doc_f2py_rout_slalib_sla_pdq2h},
  {"sla_permut",-1,{{-1}},0,(char *)F_FUNC_US(sla_permut,SLA_PERMUT),(f2py_init_func)f2py_rout_slalib_sla_permut,doc_f2py_rout_slalib_sla_permut},
  {"sla_pertel",-1,{{-1}},0,(char *)F_FUNC_US(sla_pertel,SLA_PERTEL),(f2py_init_func)f2py_rout_slalib_sla_pertel,doc_f2py_rout_slalib_sla_pertel},
  {"sla_pertue",-1,{{-1}},0,(char *)F_FUNC_US(sla_pertue,SLA_PERTUE),(f2py_init_func)f2py_rout_slalib_sla_pertue,doc_f2py_rout_slalib_sla_pertue},
  {"sla_planel",-1,{{-1}},0,(char *)F_FUNC_US(sla_planel,SLA_PLANEL),(f2py_init_func)f2py_rout_slalib_sla_planel,doc_f2py_rout_slalib_sla_planel},
  {"sla_planet",-1,{{-1}},0,(char *)F_FUNC_US(sla_planet,SLA_PLANET),(f2py_init_func)f2py_rout_slalib_sla_planet,doc_f2py_rout_slalib_sla_planet},
  {"sla_plante",-1,{{-1}},0,(char *)F_FUNC_US(sla_plante,SLA_PLANTE),(f2py_init_func)f2py_rout_slalib_sla_plante,doc_f2py_rout_slalib_sla_plante},
  {"sla_plantu",-1,{{-1}},0,(char *)F_FUNC_US(sla_plantu,SLA_PLANTU),(f2py_init_func)f2py_rout_slalib_sla_plantu,doc_f2py_rout_slalib_sla_plantu},
  {"sla_pm",-1,{{-1}},0,(char *)F_FUNC_US(sla_pm,SLA_PM),(f2py_init_func)f2py_rout_slalib_sla_pm,doc_f2py_rout_slalib_sla_pm},
  {"sla_polmo",-1,{{-1}},0,(char *)F_FUNC_US(sla_polmo,SLA_POLMO),(f2py_init_func)f2py_rout_slalib_sla_polmo,doc_f2py_rout_slalib_sla_polmo},
  {"sla_prebn",-1,{{-1}},0,(char *)F_FUNC_US(sla_prebn,SLA_PREBN),(f2py_init_func)f2py_rout_slalib_sla_prebn,doc_f2py_rout_slalib_sla_prebn},
  {"sla_preces",-1,{{-1}},0,(char *)F_FUNC_US(sla_preces,SLA_PRECES),(f2py_init_func)f2py_rout_slalib_sla_preces,doc_f2py_rout_slalib_sla_preces},
  {"sla_prec",-1,{{-1}},0,(char *)F_FUNC_US(sla_prec,SLA_PREC),(f2py_init_func)f2py_rout_slalib_sla_prec,doc_f2py_rout_slalib_sla_prec},
  {"sla_precl",-1,{{-1}},0,(char *)F_FUNC_US(sla_precl,SLA_PRECL),(f2py_init_func)f2py_rout_slalib_sla_precl,doc_f2py_rout_slalib_sla_precl},
  {"sla_prenut",-1,{{-1}},0,(char *)F_FUNC_US(sla_prenut,SLA_PRENUT),(f2py_init_func)f2py_rout_slalib_sla_prenut,doc_f2py_rout_slalib_sla_prenut},
  {"sla_pv2el",-1,{{-1}},0,(char *)F_FUNC_US(sla_pv2el,SLA_PV2EL),(f2py_init_func)f2py_rout_slalib_sla_pv2el,doc_f2py_rout_slalib_sla_pv2el},
  {"sla_pv2ue",-1,{{-1}},0,(char *)F_FUNC_US(sla_pv2ue,SLA_PV2UE),(f2py_init_func)f2py_rout_slalib_sla_pv2ue,doc_f2py_rout_slalib_sla_pv2ue},
  {"sla_pvobs",-1,{{-1}},0,(char *)F_FUNC_US(sla_pvobs,SLA_PVOBS),(f2py_init_func)f2py_rout_slalib_sla_pvobs,doc_f2py_rout_slalib_sla_pvobs},
  {"sla_pxy",-1,{{-1}},0,(char *)F_FUNC_US(sla_pxy,SLA_PXY),(f2py_init_func)f2py_rout_slalib_sla_pxy,doc_f2py_rout_slalib_sla_pxy},
  {"sla_range",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_range,SLA_RANGE),(f2py_init_func)f2py_rout_slalib_sla_range,doc_f2py_rout_slalib_sla_range},
  {"sla_ranorm",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_ranorm,SLA_RANORM),(f2py_init_func)f2py_rout_slalib_sla_ranorm,doc_f2py_rout_slalib_sla_ranorm},
  {"sla_rcc",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_rcc,SLA_RCC),(f2py_init_func)f2py_rout_slalib_sla_rcc,doc_f2py_rout_slalib_sla_rcc},
  {"sla_rdplan",-1,{{-1}},0,(char *)F_FUNC_US(sla_rdplan,SLA_RDPLAN),(f2py_init_func)f2py_rout_slalib_sla_rdplan,doc_f2py_rout_slalib_sla_rdplan},
  {"sla_refco",-1,{{-1}},0,(char *)F_FUNC_US(sla_refco,SLA_REFCO),(f2py_init_func)f2py_rout_slalib_sla_refco,doc_f2py_rout_slalib_sla_refco},
  {"sla_refcoq",-1,{{-1}},0,(char *)F_FUNC_US(sla_refcoq,SLA_REFCOQ),(f2py_init_func)f2py_rout_slalib_sla_refcoq,doc_f2py_rout_slalib_sla_refcoq},
  {"sla_refro",-1,{{-1}},0,(char *)F_FUNC_US(sla_refro,SLA_REFRO),(f2py_init_func)f2py_rout_slalib_sla_refro,doc_f2py_rout_slalib_sla_refro},
  {"sla_refv",-1,{{-1}},0,(char *)F_FUNC_US(sla_refv,SLA_REFV),(f2py_init_func)f2py_rout_slalib_sla_refv,doc_f2py_rout_slalib_sla_refv},
  {"sla_refz",-1,{{-1}},0,(char *)F_FUNC_US(sla_refz,SLA_REFZ),(f2py_init_func)f2py_rout_slalib_sla_refz,doc_f2py_rout_slalib_sla_refz},
  {"sla_rverot",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_rverot,SLA_RVEROT),(f2py_init_func)f2py_rout_slalib_sla_rverot,doc_f2py_rout_slalib_sla_rverot},
  {"sla_rvgalc",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_rvgalc,SLA_RVGALC),(f2py_init_func)f2py_rout_slalib_sla_rvgalc,doc_f2py_rout_slalib_sla_rvgalc},
  {"sla_rvlg",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_rvlg,SLA_RVLG),(f2py_init_func)f2py_rout_slalib_sla_rvlg,doc_f2py_rout_slalib_sla_rvlg},
  {"sla_rvlsrd",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_rvlsrd,SLA_RVLSRD),(f2py_init_func)f2py_rout_slalib_sla_rvlsrd,doc_f2py_rout_slalib_sla_rvlsrd},
  {"sla_rvlsrk",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_rvlsrk,SLA_RVLSRK),(f2py_init_func)f2py_rout_slalib_sla_rvlsrk,doc_f2py_rout_slalib_sla_rvlsrk},
  {"sla_s2tp",-1,{{-1}},0,(char *)F_FUNC_US(sla_s2tp,SLA_S2TP),(f2py_init_func)f2py_rout_slalib_sla_s2tp,doc_f2py_rout_slalib_sla_s2tp},
  {"sla_sep",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_sep,SLA_SEP),(f2py_init_func)f2py_rout_slalib_sla_sep,doc_f2py_rout_slalib_sla_sep},
  {"sla_sepv",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_sepv,SLA_SEPV),(f2py_init_func)f2py_rout_slalib_sla_sepv,doc_f2py_rout_slalib_sla_sepv},
  {"sla_smat",-1,{{-1}},0,(char *)F_FUNC_US(sla_smat,SLA_SMAT),(f2py_init_func)f2py_rout_slalib_sla_smat,doc_f2py_rout_slalib_sla_smat},
  {"sla_subet",-1,{{-1}},0,(char *)F_FUNC_US(sla_subet,SLA_SUBET),(f2py_init_func)f2py_rout_slalib_sla_subet,doc_f2py_rout_slalib_sla_subet},
  {"sla_supgal",-1,{{-1}},0,(char *)F_FUNC_US(sla_supgal,SLA_SUPGAL),(f2py_init_func)f2py_rout_slalib_sla_supgal,doc_f2py_rout_slalib_sla_supgal},
  {"sla_svdcov",-1,{{-1}},0,(char *)F_FUNC_US(sla_svdcov,SLA_SVDCOV),(f2py_init_func)f2py_rout_slalib_sla_svdcov,doc_f2py_rout_slalib_sla_svdcov},
  {"sla_svd",-1,{{-1}},0,(char *)F_FUNC_US(sla_svd,SLA_SVD),(f2py_init_func)f2py_rout_slalib_sla_svd,doc_f2py_rout_slalib_sla_svd},
  {"sla_svdsol",-1,{{-1}},0,(char *)F_FUNC_US(sla_svdsol,SLA_SVDSOL),(f2py_init_func)f2py_rout_slalib_sla_svdsol,doc_f2py_rout_slalib_sla_svdsol},
  {"sla_tp2s",-1,{{-1}},0,(char *)F_FUNC_US(sla_tp2s,SLA_TP2S),(f2py_init_func)f2py_rout_slalib_sla_tp2s,doc_f2py_rout_slalib_sla_tp2s},
  {"sla_tp2v",-1,{{-1}},0,(char *)F_FUNC_US(sla_tp2v,SLA_TP2V),(f2py_init_func)f2py_rout_slalib_sla_tp2v,doc_f2py_rout_slalib_sla_tp2v},
  {"sla_tps2c",-1,{{-1}},0,(char *)F_FUNC_US(sla_tps2c,SLA_TPS2C),(f2py_init_func)f2py_rout_slalib_sla_tps2c,doc_f2py_rout_slalib_sla_tps2c},
  {"sla_tpv2c",-1,{{-1}},0,(char *)F_FUNC_US(sla_tpv2c,SLA_TPV2C),(f2py_init_func)f2py_rout_slalib_sla_tpv2c,doc_f2py_rout_slalib_sla_tpv2c},
  {"sla_ue2el",-1,{{-1}},0,(char *)F_FUNC_US(sla_ue2el,SLA_UE2EL),(f2py_init_func)f2py_rout_slalib_sla_ue2el,doc_f2py_rout_slalib_sla_ue2el},
  {"sla_ue2pv",-1,{{-1}},0,(char *)F_FUNC_US(sla_ue2pv,SLA_UE2PV),(f2py_init_func)f2py_rout_slalib_sla_ue2pv,doc_f2py_rout_slalib_sla_ue2pv},
  {"sla_unpcd",-1,{{-1}},0,(char *)F_FUNC_US(sla_unpcd,SLA_UNPCD),(f2py_init_func)f2py_rout_slalib_sla_unpcd,doc_f2py_rout_slalib_sla_unpcd},
  {"sla_v2tp",-1,{{-1}},0,(char *)F_FUNC_US(sla_v2tp,SLA_V2TP),(f2py_init_func)f2py_rout_slalib_sla_v2tp,doc_f2py_rout_slalib_sla_v2tp},
  {"sla_vdv",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_vdv,SLA_VDV),(f2py_init_func)f2py_rout_slalib_sla_vdv,doc_f2py_rout_slalib_sla_vdv},
  {"sla_veri",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_veri,SLA_VERI),(f2py_init_func)f2py_rout_slalib_sla_veri,doc_f2py_rout_slalib_sla_veri},
  {"sla_vn",-1,{{-1}},0,(char *)F_FUNC_US(sla_vn,SLA_VN),(f2py_init_func)f2py_rout_slalib_sla_vn,doc_f2py_rout_slalib_sla_vn},
  {"sla_vxv",-1,{{-1}},0,(char *)F_FUNC_US(sla_vxv,SLA_VXV),(f2py_init_func)f2py_rout_slalib_sla_vxv,doc_f2py_rout_slalib_sla_vxv},
  {"sla_wait",-1,{{-1}},0,(char *)F_FUNC_US(sla_wait,SLA_WAIT),(f2py_init_func)f2py_rout_slalib_sla_wait,doc_f2py_rout_slalib_sla_wait},
  {"sla_xy2xy",-1,{{-1}},0,(char *)F_FUNC_US(sla_xy2xy,SLA_XY2XY),(f2py_init_func)f2py_rout_slalib_sla_xy2xy,doc_f2py_rout_slalib_sla_xy2xy},
  {"sla_zd",-1,{{-1}},0,(char *)F_WRAPPEDFUNC_US(sla_zd,SLA_ZD),(f2py_init_func)f2py_rout_slalib_sla_zd,doc_f2py_rout_slalib_sla_zd},

/*eof routine_defs*/
  {NULL}
};

static PyMethodDef f2py_module_methods[] = {

  {NULL,NULL}
};

PyMODINIT_FUNC initslalib(void) {
  int i;
  PyObject *m,*d, *s;
  m = slalib_module = Py_InitModule("slalib", f2py_module_methods);
  PyFortran_Type.ob_type = &PyType_Type;
  import_array();
  if (PyErr_Occurred())
    {PyErr_SetString(PyExc_ImportError, "can't initialize module slalib (failed to import numpy)"); return;}
  d = PyModule_GetDict(m);
  s = PyString_FromString("$Revision: $");
  PyDict_SetItemString(d, "__version__", s);
  s = PyString_FromString("This module 'slalib' is auto-generated with f2py (version:2_4422).\nFunctions:\n"
"  rc,dc = sla_addet(rm,dm,eq)\n"
"  iptr,a,j = sla_afin(string_bn,iptr)\n"
"  sla_airmas = sla_airmas(zd)\n"
"  az,azd,azdd,el,eld,eldd,pa,pad,padd = sla_altaz(ha,dec,phi)\n"
"  rm,dm = sla_amp(ra,da,date,eq)\n"
"  rm,dm = sla_ampqk(ra,da,amprms)\n"
"  aob,zob,hob,dob,rob = sla_aop(rap,dap,date,dut,elongm,phim,hm,xp,yp,tdk,pmb,rh,wl,tlr)\n"
"  aoprms = sla_aoppa(date,dut,elongm,phim,hm,xp,yp,tdk,pmb,rh,wl,tlr)\n"
"  aoprms = sla_aoppat(date,aoprms)\n"
"  aob,zob,hob,dob,rob = sla_aopqk(rap,dap,aoprms)\n"
"  a2,b2 = sla_atmdsp(tdk,pmb,rh,wl1,a1,b1,wl2)\n"
"  sla__atms(rt,tt,dnt,gamal,r,dn,rdndr)\n"
"  sla__atmt(r0,t0,alpha,gamm2,delm2,c1,c2,c3,c4,c5,c6,r,t,dn,rdndr)\n"
"  rmat = sla_av2m(axvec)\n"
"  sla_bear = sla_bear(a1,b1,a2,b2)\n"
"  rad,j = sla_caf2r(ideg,iamin,asec)\n"
"  djm,j = sla_caldj(iy,im,id)\n"
"  ny,nd,j = sla_calyd(iy,im,id)\n"
"  a,b = sla_cc2s(v)\n"
"  a,b,r,ad,bd,rd = sla_cc62s(v)\n"
"  sign,ihmsf = sla_cd2tf(ndp,days)\n"
"  djm,j = sla_cldj(iy,im,id)\n"
"  ny,nd,jstat = sla_clyd(iy,im,id)\n"
"  list,j = sla_combn(ncand,list,nsel=len(list))\n"
"  sign,idmsf = sla_cr2af(ndp,angle)\n"
"  sign,ihmsf = sla_cr2tf(ndp,angle)\n"
"  v = sla_cs2c6(a,b,r,ad,bd,rd)\n"
"  v = sla_cs2c(a,b)\n"
"  days,j = sla_ctf2d(ihour,imin,sec)\n"
"  rad,j = sla_ctf2r(ihour,imin,sec)\n"
"  rad,j = sla_daf2r(ideg,iamin,asec)\n"
"  iptr,a,j = sla_dafin(string_bn,iptr)\n"
"  sla_dat = sla_dat(utc)\n"
"  rmat = sla_dav2m(axvec)\n"
"  sla_dbear = sla_dbear(a1,b1,a2,b2)\n"
"  nstrt,dreslt,j1,j2 = sla_dbjin(string_bn,nstrt)\n"
"  a,b,r,ad,bd,rd = sla_dc62s(v)\n"
"  a,b = sla_dcc2s(v)\n"
"  xz,yz,xs,ys,perp,orient = sla_dcmpf(coeffs)\n"
"  v = sla_dcs2c(a,b)\n"
"  sign,ihmsf = sla_dd2tf(ndp,days)\n"
"  az,el = sla_de2h(ha,dec,phi)\n"
"  rmat = sla_deuler(order,phi,theta,psi)\n"
"  nstrt,dreslt,jflag = sla_dfltin(string_bn,nstrt)\n"
"  ha,dec = sla_dh2e(az,el,phi)\n"
"  vb = sla_dimxv(dm,va)\n"
"  iymdf,j = sla_djcal(ndp,djm)\n"
"  iy,im,id,fd,j = sla_djcl(djm)\n"
"  axvec = sla_dm2av(rmat)\n"
"  a,y,d,jf,iw = sla_dmat(a,y,iw,n=shape(a,0))\n"
"  pv = sla_dmoon(date)\n"
"  c = sla_dmxm(a,b)\n"
"  vb = sla_dmxv(dm,va)\n"
"  sla_dpav = sla_dpav(v1,v2)\n"
"  sign,idmsf = sla_dr2af(ndp,angle)\n"
"  sign,ihmsf = sla_dr2tf(ndp,angle)\n"
"  sla_drange = sla_drange(angle)\n"
"  sla_dranrm = sla_dranrm(angle)\n"
"  v = sla_ds2c6(a,b,r,ad,bd,rd)\n"
"  xi,eta,j = sla_ds2tp(ra,dec,raz,decz)\n"
"  sla_dsep = sla_dsep(a1,b1,a2,b2)\n"
"  sla_dsepv = sla_dsepv(v1,v2)\n"
"  sla_dt = sla_dt(epoch)\n"
"  days,j = sla_dtf2d(ihour,imin,sec)\n"
"  rad,j = sla_dtf2r(ihour,imin,sec)\n"
"  ra,dec = sla_dtp2s(xi,eta,raz,decz)\n"
"  v = sla_dtp2v(xi,eta,v0)\n"
"  raz1,decz1,raz2,decz2,n = sla_dtps2c(xi,eta,ra,dec)\n"
"  v01,v02,n = sla_dtpv2c(xi,eta,v)\n"
"  sla_dtt = sla_dtt(utc)\n"
"  xi,eta,j = sla_dv2tp(v,v0)\n"
"  sla_dvdv = sla_dvdv(va,vb)\n"
"  uv,vm = sla_dvn(v)\n"
"  vc = sla_dvxv(va,vb)\n"
"  az,el = sla_e2h(ha,dec,phi)\n"
"  pv = sla_earth(iy,id,fd)\n"
"  dr,dd = sla_ecleq(dl,db,date)\n"
"  rmat = sla_ecmat(date)\n"
"  rv,tl = sla_ecor(rm,dm,iy,id,fd)\n"
"  dl,db = sla_eg50(dr,dd)\n"
"  u,jstat = sla_el2ue(date,jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm)\n"
"  sla_epb2d = sla_epb2d(epb)\n"
"  sla_epb = sla_epb(date)\n"
"  sla_epco = sla_epco(k0,k,e)\n"
"  sla_epj2d = sla_epj2d(epj)\n"
"  sla_epj = sla_epj(date)\n"
"  ph,vh,pb,vb = sla_epv(date)\n"
"  dl,db = sla_eqecl(dr,dd,date)\n"
"  sla_eqeqx = sla_eqeqx(date)\n"
"  dl,db = sla_eqgal(dr,dd)\n"
"  ev = sla_etrms(ep)\n"
"  rmat = sla_euler(order,phi,theta,psi)\n"
"  dvb,dpb,dvh,dph = sla_evp(date,deqx)\n"
"  coeffs,j = sla_fitxy(itype,xye,xym,np=shape(xye,1))\n"
"  r2000,d2000,dr2000,dd2000,p2000,v2000 = sla_fk425(r1950,d1950,dr1950,dd1950,p1950,v1950)\n"
"  r2000,d2000 = sla_fk45z(r1950,d1950,bepoch)\n"
"  r1950,d1950,dr1950,dd1950,p1950,v1950 = sla_fk524(r2000,d2000,dr2000,dd2000,p2000,v2000)\n"
"  rh,dh,drh,ddh = sla_fk52h(r5,d5,dr5,dd5)\n"
"  r1950,d1950,dr1950,dd1950 = sla_fk54z(r2000,d2000,bepoch)\n"
"  rh,dh = sla_fk5hz(r5,d5,epoch)\n"
"  nstrt,reslt,jflag = sla_flotin(string_bn,nstrt)\n"
"  dr,dd = sla_galeq(dl,db)\n"
"  dsl,dsb = sla_galsup(dl,db)\n"
"  dr,dd = sla_ge50(dl,db)\n"
"  r,z = sla_geoc(p,h)\n"
"  sla_gmsta = sla_gmsta(date,ut)\n"
"  sla_gmst = sla_gmst(ut1)\n"
"  ha,dec = sla_h2e(az,el,phi)\n"
"  r5,d5,dr5,dd5 = sla_h2fk5(rh,dh,drh,ddh)\n"
"  r5,d5,dr5,dd5 = sla_hfk5z(rh,dh,epoch)\n"
"  nptr,nvec,ndigit,digit = sla__idchf(string_bn,nptr)\n"
"  nptr,nvec,digit = sla__idchi(string_bn,nptr)\n"
"  vb = sla_imxv(rm,va)\n"
"  nstrt,ireslt,jflag = sla_intin(string_bn,nstrt)\n"
"  bkwds,j = sla_invf(fwds)\n"
"  k,j = sla_kbj(jb,e)\n"
"  axvec = sla_m2av(rmat)\n"
"  ra,da = sla_map(rm,dm,pr,pd,px,rv,eq,date)\n"
"  amprms = sla_mappa(eq,date)\n"
"  ra,da = sla_mapqk(rm,dm,pr,pd,px,rv,amprms)\n"
"  ra,da = sla_mapqkz(rm,dm,amprms)\n"
"  pv = sla_moon(iy,id,fd)\n"
"  c = sla_mxm(a,b)\n"
"  vb = sla_mxv(rm,va)\n"
"  dpsi,deps,eps0 = sla_nutc80(date)\n"
"  dpsi,deps,eps0 = sla_nutc(date)\n"
"  rmatn = sla_nut(date)\n"
"  rap,dap = sla_oap(type_bn,ob1,ob2,date,dut,elongm,phim,hm,xp,yp,tdk,pmb,rh,wl,tlr)\n"
"  rap,dap = sla_oapqk(type_bn,ob1,ob2,aoprms)\n"
"  c,name,w,p,h = sla_obs(n,c)\n"
"  sla_pa = sla_pa(ha,dec,phi)\n"
"  sla_pav = sla_pav(v1,v2)\n"
"  x,y = sla_pcd(disco,x,y)\n"
"  h1,j1,h2,j2 = sla_pda2h(p,d,a)\n"
"  h1,j1,h2,j2 = sla_pdq2h(p,d,q)\n"
"  istate,iorder,j = sla_permut(istate,n=len(istate))\n"
"  epoch1,orbi1,anode1,perih1,aorq1,e1,am1,jstat = sla_pertel(jform,date0,date1,epoch0,orbi0,anode0,perih0,aorq0,e0,am0)\n"
"  u,jstat = sla_pertue(date,u)\n"
"  pv,jstat = sla_planel(date,jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm)\n"
"  pv,jstat = sla_planet(date,np)\n"
"  ra,dec,r,jstat = sla_plante(date,elong,phi,jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm)\n"
"  ra,dec,r,jstat = sla_plantu(date,elong,phi,u)\n"
"  r1,d1 = sla_pm(r0,d0,pr,pd,px,rv,ep0,ep1)\n"
"  elong,phi,daz = sla_polmo(elongm,phim,xp,yp)\n"
"  rmatp = sla_prebn(bep0,bep1)\n"
"  ra,dc = sla_preces(system,ep0,ep1,ra,dc)\n"
"  rmatp = sla_prec(ep0,ep1)\n"
"  rmatp = sla_precl(ep0,ep1)\n"
"  rmatpn = sla_prenut(epoch,date)\n"
"  jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm,jstat = sla_pv2el(pv,date,pmass,jformr)\n"
"  u,jstat = sla_pv2ue(pv,date,pmass)\n"
"  pv = sla_pvobs(p,h,stl)\n"
"  xyp,xrms,yrms,rrms = sla_pxy(xye,xym,coeffs,np=shape(xye,1))\n"
"  sla_range = sla_range(angle)\n"
"  sla_ranorm = sla_ranorm(angle)\n"
"  sla_rcc = sla_rcc(tdb,ut1,wl,u,v)\n"
"  ra,dec,diam = sla_rdplan(date,np,elong,phi)\n"
"  refa,refb = sla_refco(hm,tdk,pmb,rh,wl,phi,tlr,eps)\n"
"  refa,refb = sla_refcoq(tdk,pmb,rh,wl)\n"
"  ref = sla_refro(zobs,hm,tdk,pmb,rh,wl,phi,tlr,eps)\n"
"  vr = sla_refv(vu,refa,refb)\n"
"  zr = sla_refz(zu,refa,refb)\n"
"  sla_rverot = sla_rverot(phi,ra,da,st)\n"
"  sla_rvgalc = sla_rvgalc(r2000,d2000)\n"
"  sla_rvlg = sla_rvlg(r2000,d2000)\n"
"  sla_rvlsrd = sla_rvlsrd(r2000,d2000)\n"
"  sla_rvlsrk = sla_rvlsrk(r2000,d2000)\n"
"  xi,eta,j = sla_s2tp(ra,dec,raz,decz)\n"
"  sla_sep = sla_sep(a1,b1,a2,b2)\n"
"  sla_sepv = sla_sepv(v1,v2)\n"
"  a,y,d,jf,iw = sla_smat(a,y,iw,n=shape(a,0))\n"
"  rm,dm = sla_subet(rc,dc,eq)\n"
"  dl,db = sla_supgal(dsl,dsb)\n"
"  work,cvm = sla_svdcov(w,v,n=len(w),np=shape(v,0),nc=n)\n"
"  a,w,v,work,jstat = sla_svd(m,n,a,mp=shape(a,0),np=shape(a,1))\n"
"  work,x = sla_svdsol(b,u,w,v,m=len(b),n=len(w),mp=shape(u,0),np=shape(u,1))\n"
"  ra,dec = sla_tp2s(xi,eta,raz,decz)\n"
"  v = sla_tp2v(xi,eta,v0)\n"
"  raz1,decz1,raz2,decz2,n = sla_tps2c(xi,eta,ra,dec)\n"
"  v01,v02,n = sla_tpv2c(xi,eta,v)\n"
"  jform,epoch,orbinc,anode,perih,aorq,e,aorl,dm,jstat = sla_ue2el(u,jformr)\n"
"  u,pv,jstat = sla_ue2pv(date,u)\n"
"  x,y = sla_unpcd(disco,x,y)\n"
"  xi,eta,j = sla_v2tp(v,v0)\n"
"  sla_vdv = sla_vdv(va,vb)\n"
"  sla_veri = sla_veri()\n"
"  uv,vm = sla_vn(v)\n"
"  vc = sla_vxv(va,vb)\n"
"  sla_wait(delay)\n"
"  x2,y2 = sla_xy2xy(x1,y1,coeffs)\n"
"  sla_zd = sla_zd(ha,dec,phi)\n"
".");
  PyDict_SetItemString(d, "__doc__", s);
  slalib_error = PyErr_NewException ("slalib.error", NULL, NULL);
  Py_DECREF(s);
  for(i=0;f2py_routine_defs[i].name!=NULL;i++)
    PyDict_SetItemString(d, f2py_routine_defs[i].name,PyFortranObject_NewAsAttr(&f2py_routine_defs[i]));



    {
      extern double F_FUNC_US(sla_airmas,SLA_AIRMAS)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_airmas");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_airmas,SLA_AIRMAS),NULL));
    }
    












    {
      extern float F_FUNC_US(sla_bear,SLA_BEAR)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_bear");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_bear,SLA_BEAR),NULL));
    }
    


















    {
      extern double F_FUNC_US(sla_dat,SLA_DAT)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_dat");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_dat,SLA_DAT),NULL));
    }
    


    {
      extern double F_FUNC_US(sla_dbear,SLA_DBEAR)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_dbear");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_dbear,SLA_DBEAR),NULL));
    }
    



















    {
      extern double F_FUNC_US(sla_dpav,SLA_DPAV)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_dpav");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_dpav,SLA_DPAV),NULL));
    }
    



    {
      extern double F_FUNC_US(sla_drange,SLA_DRANGE)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_drange");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_drange,SLA_DRANGE),NULL));
    }
    

    {
      extern double F_FUNC_US(sla_dranrm,SLA_DRANRM)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_dranrm");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_dranrm,SLA_DRANRM),NULL));
    }
    



    {
      extern double F_FUNC_US(sla_dsep,SLA_DSEP)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_dsep");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_dsep,SLA_DSEP),NULL));
    }
    

    {
      extern double F_FUNC_US(sla_dsepv,SLA_DSEPV)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_dsepv");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_dsepv,SLA_DSEPV),NULL));
    }
    

    {
      extern double F_FUNC_US(sla_dt,SLA_DT)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_dt");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_dt,SLA_DT),NULL));
    }
    







    {
      extern double F_FUNC_US(sla_dtt,SLA_DTT)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_dtt");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_dtt,SLA_DTT),NULL));
    }
    


    {
      extern double F_FUNC_US(sla_dvdv,SLA_DVDV)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_dvdv");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_dvdv,SLA_DVDV),NULL));
    }
    










    {
      extern double F_FUNC_US(sla_epb2d,SLA_EPB2D)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_epb2d");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_epb2d,SLA_EPB2D),NULL));
    }
    

    {
      extern double F_FUNC_US(sla_epb,SLA_EPB)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_epb");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_epb,SLA_EPB),NULL));
    }
    

    {
      extern double F_FUNC_US(sla_epco,SLA_EPCO)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_epco");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_epco,SLA_EPCO),NULL));
    }
    

    {
      extern double F_FUNC_US(sla_epj2d,SLA_EPJ2D)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_epj2d");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_epj2d,SLA_EPJ2D),NULL));
    }
    

    {
      extern double F_FUNC_US(sla_epj,SLA_EPJ)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_epj");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_epj,SLA_EPJ),NULL));
    }
    



    {
      extern double F_FUNC_US(sla_eqeqx,SLA_EQEQX)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_eqeqx");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_eqeqx,SLA_EQEQX),NULL));
    }
    

















    {
      extern double F_FUNC_US(sla_gmsta,SLA_GMSTA)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_gmsta");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_gmsta,SLA_GMSTA),NULL));
    }
    

    {
      extern double F_FUNC_US(sla_gmst,SLA_GMST)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_gmst");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_gmst,SLA_GMST),NULL));
    }
    
























    {
      extern double F_FUNC_US(sla_pa,SLA_PA)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_pa");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_pa,SLA_PA),NULL));
    }
    

    {
      extern float F_FUNC_US(sla_pav,SLA_PAV)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_pav");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_pav,SLA_PAV),NULL));
    }
    






















    {
      extern float F_FUNC_US(sla_range,SLA_RANGE)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_range");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_range,SLA_RANGE),NULL));
    }
    

    {
      extern float F_FUNC_US(sla_ranorm,SLA_RANORM)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_ranorm");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_ranorm,SLA_RANORM),NULL));
    }
    

    {
      extern double F_FUNC_US(sla_rcc,SLA_RCC)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_rcc");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_rcc,SLA_RCC),NULL));
    }
    







    {
      extern float F_FUNC_US(sla_rverot,SLA_RVEROT)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_rverot");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_rverot,SLA_RVEROT),NULL));
    }
    

    {
      extern float F_FUNC_US(sla_rvgalc,SLA_RVGALC)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_rvgalc");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_rvgalc,SLA_RVGALC),NULL));
    }
    

    {
      extern float F_FUNC_US(sla_rvlg,SLA_RVLG)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_rvlg");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_rvlg,SLA_RVLG),NULL));
    }
    

    {
      extern float F_FUNC_US(sla_rvlsrd,SLA_RVLSRD)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_rvlsrd");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_rvlsrd,SLA_RVLSRD),NULL));
    }
    

    {
      extern float F_FUNC_US(sla_rvlsrk,SLA_RVLSRK)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_rvlsrk");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_rvlsrk,SLA_RVLSRK),NULL));
    }
    


    {
      extern float F_FUNC_US(sla_sep,SLA_SEP)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_sep");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_sep,SLA_SEP),NULL));
    }
    

    {
      extern float F_FUNC_US(sla_sepv,SLA_SEPV)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_sepv");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_sepv,SLA_SEPV),NULL));
    }
    















    {
      extern float F_FUNC_US(sla_vdv,SLA_VDV)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_vdv");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_vdv,SLA_VDV),NULL));
    }
    

    {
      extern int F_FUNC_US(sla_veri,SLA_VERI)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_veri");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_veri,SLA_VERI),NULL));
    }
    





    {
      extern double F_FUNC_US(sla_zd,SLA_ZD)(void);
      PyObject* o = PyDict_GetItemString(d,"sla_zd");
      PyObject_SetAttrString(o,"_cpointer", PyCObject_FromVoidPtr((void*)F_FUNC_US(sla_zd,SLA_ZD),NULL));
    }
    
/*eof initf2pywraphooks*/
/*eof initf90modhooks*/

/*eof initcommonhooks*/


#ifdef F2PY_REPORT_ATEXIT
  if (! PyErr_Occurred())
    on_exit(f2py_report_on_exit,(void*)"slalib");
#endif

}
#ifdef __cplusplus
}
#endif
