# This file was created automatically by SWIG.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

import _slalib

def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "this"):
        if isinstance(value, class_type):
            self.__dict__[name] = value.this
            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
            del value.thisown
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name) or (name == "thisown"):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


class doubleArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, doubleArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, doubleArray, name)
    def __repr__(self):
        return "<%s.%s; proxy of C doubleArray instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, doubleArray, 'this', _slalib.new_doubleArray(*args))
        _swig_setattr(self, doubleArray, 'thisown', 1)
    def __del__(self, destroy=_slalib.delete_doubleArray):
        try:
            if self.thisown: destroy(self)
        except: pass

    def __getitem__(*args): return _slalib.doubleArray___getitem__(*args)
    def __setitem__(*args): return _slalib.doubleArray___setitem__(*args)
    def cast(*args): return _slalib.doubleArray_cast(*args)
    __swig_getmethods__["frompointer"] = lambda x: _slalib.doubleArray_frompointer
    if _newclass:frompointer = staticmethod(_slalib.doubleArray_frompointer)

class doubleArrayPtr(doubleArray):
    def __init__(self, this):
        _swig_setattr(self, doubleArray, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, doubleArray, 'thisown', 0)
        _swig_setattr(self, doubleArray,self.__class__,doubleArray)
_slalib.doubleArray_swigregister(doubleArrayPtr)

doubleArray_frompointer = _slalib.doubleArray_frompointer

class floatArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, floatArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, floatArray, name)
    def __repr__(self):
        return "<%s.%s; proxy of C floatArray instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, floatArray, 'this', _slalib.new_floatArray(*args))
        _swig_setattr(self, floatArray, 'thisown', 1)
    def __del__(self, destroy=_slalib.delete_floatArray):
        try:
            if self.thisown: destroy(self)
        except: pass

    def __getitem__(*args): return _slalib.floatArray___getitem__(*args)
    def __setitem__(*args): return _slalib.floatArray___setitem__(*args)
    def cast(*args): return _slalib.floatArray_cast(*args)
    __swig_getmethods__["frompointer"] = lambda x: _slalib.floatArray_frompointer
    if _newclass:frompointer = staticmethod(_slalib.floatArray_frompointer)

class floatArrayPtr(floatArray):
    def __init__(self, this):
        _swig_setattr(self, floatArray, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, floatArray, 'thisown', 0)
        _swig_setattr(self, floatArray,self.__class__,floatArray)
_slalib.floatArray_swigregister(floatArrayPtr)

floatArray_frompointer = _slalib.floatArray_frompointer

class intArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, intArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, intArray, name)
    def __repr__(self):
        return "<%s.%s; proxy of C intArray instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        _swig_setattr(self, intArray, 'this', _slalib.new_intArray(*args))
        _swig_setattr(self, intArray, 'thisown', 1)
    def __del__(self, destroy=_slalib.delete_intArray):
        try:
            if self.thisown: destroy(self)
        except: pass

    def __getitem__(*args): return _slalib.intArray___getitem__(*args)
    def __setitem__(*args): return _slalib.intArray___setitem__(*args)
    def cast(*args): return _slalib.intArray_cast(*args)
    __swig_getmethods__["frompointer"] = lambda x: _slalib.intArray_frompointer
    if _newclass:frompointer = staticmethod(_slalib.intArray_frompointer)

class intArrayPtr(intArray):
    def __init__(self, this):
        _swig_setattr(self, intArray, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, intArray, 'thisown', 0)
        _swig_setattr(self, intArray,self.__class__,intArray)
_slalib.intArray_swigregister(intArrayPtr)

intArray_frompointer = _slalib.intArray_frompointer


def slaAddet(*args):
    """slaAddet(double rm, double dm, double eq, double rc, double dc)"""
    return _slalib.slaAddet(*args)

def slaAfin(*args):
    """slaAfin(char string, int iptr, float a, int j)"""
    return _slalib.slaAfin(*args)

def slaAirmas(*args):
    """slaAirmas(double zd) -> double"""
    return _slalib.slaAirmas(*args)

def slaAltaz(*args):
    """
    slaAltaz(double ha, double dec, double phi, double az, double azd, 
        double azdd, double el, double eld, double eldd, 
        double pa, double pad, double padd)
    """
    return _slalib.slaAltaz(*args)

def slaAmp(*args):
    """
    slaAmp(double ra, double da, double date, double eq, double rm, 
        double dm)
    """
    return _slalib.slaAmp(*args)

def slaAmpqk(*args):
    """slaAmpqk(double ra, double da, double amprms, double rm, double dm)"""
    return _slalib.slaAmpqk(*args)

def slaAop(*args):
    """
    slaAop(double rap, double dap, double date, double dut, double elongm, 
        double phim, double hm, double xp, 
        double yp, double tdk, double pmb, double rh, 
        double wl, double tlr, double aob, double zob, 
        double hob, double dob, double rob)
    """
    return _slalib.slaAop(*args)

def slaAoppa(*args):
    """
    slaAoppa(double date, double dut, double elongm, double phim, 
        double hm, double xp, double yp, double tdk, 
        double pmb, double rh, double wl, double tlr, 
        double aoprms)
    """
    return _slalib.slaAoppa(*args)

def slaAoppat(*args):
    """slaAoppat(double date, double aoprms)"""
    return _slalib.slaAoppat(*args)

def slaAopqk(*args):
    """
    slaAopqk(double rap, double dap, double aoprms, double aob, 
        double zob, double hob, double dob, double rob)
    """
    return _slalib.slaAopqk(*args)

def slaAtmdsp(*args):
    """
    slaAtmdsp(double tdk, double pmb, double rh, double wl1, double a1, 
        double b1, double wl2, double a2, double b2)
    """
    return _slalib.slaAtmdsp(*args)

def slaAv2m(*args):
    """slaAv2m(float axvec, float rmat)"""
    return _slalib.slaAv2m(*args)

def slaBear(*args):
    """slaBear(float a1, float b1, float a2, float b2) -> float"""
    return _slalib.slaBear(*args)

def slaCaf2r(*args):
    """slaCaf2r(int ideg, int iamin, float asec, float rad, int j)"""
    return _slalib.slaCaf2r(*args)

def slaCaldj(*args):
    """slaCaldj(int iy, int im, int id, double djm, int j)"""
    return _slalib.slaCaldj(*args)

def slaCalyd(*args):
    """slaCalyd(int iy, int im, int id, int ny, int nd, int j)"""
    return _slalib.slaCalyd(*args)

def slaCc2s(*args):
    """slaCc2s(float v, float a, float b)"""
    return _slalib.slaCc2s(*args)

def slaCc62s(*args):
    """
    slaCc62s(float v, float a, float b, float r, float ad, float bd, 
        float rd)
    """
    return _slalib.slaCc62s(*args)

def slaCd2tf(*args):
    """slaCd2tf(int ndp, float days, char sign, int ihmsf)"""
    return _slalib.slaCd2tf(*args)

def slaCldj(*args):
    """slaCldj(int iy, int im, int id, double djm, int j)"""
    return _slalib.slaCldj(*args)

def slaClyd(*args):
    """slaClyd(int iy, int im, int id, int ny, int nd, int jstat)"""
    return _slalib.slaClyd(*args)

def slaCombn(*args):
    """slaCombn(int nsel, int ncand, int list, int j)"""
    return _slalib.slaCombn(*args)

def slaCr2af(*args):
    """slaCr2af(int ndp, float angle, char sign, int idmsf)"""
    return _slalib.slaCr2af(*args)

def slaCr2tf(*args):
    """slaCr2tf(int ndp, float angle, char sign, int ihmsf)"""
    return _slalib.slaCr2tf(*args)

def slaCs2c(*args):
    """slaCs2c(float a, float b, float v)"""
    return _slalib.slaCs2c(*args)

def slaCs2c6(*args):
    """
    slaCs2c6(float a, float b, float r, float ad, float bd, float rd, 
        float v)
    """
    return _slalib.slaCs2c6(*args)

def slaCtf2d(*args):
    """slaCtf2d(int ihour, int imin, float sec, float days, int j)"""
    return _slalib.slaCtf2d(*args)

def slaCtf2r(*args):
    """slaCtf2r(int ihour, int imin, float sec, float rad, int j)"""
    return _slalib.slaCtf2r(*args)

def slaDaf2r(*args):
    """slaDaf2r(int ideg, int iamin, double asec, double rad, int j)"""
    return _slalib.slaDaf2r(*args)

def slaDafin(*args):
    """slaDafin(char string, int iptr, double a, int j)"""
    return _slalib.slaDafin(*args)

def slaDat(*args):
    """slaDat(double dju) -> double"""
    return _slalib.slaDat(*args)

def slaDav2m(*args):
    """slaDav2m(double axvec, double rmat)"""
    return _slalib.slaDav2m(*args)

def slaDbear(*args):
    """slaDbear(double a1, double b1, double a2, double b2) -> double"""
    return _slalib.slaDbear(*args)

def slaDbjin(*args):
    """slaDbjin(char string, int nstrt, double dreslt, int jf1, int jf2)"""
    return _slalib.slaDbjin(*args)

def slaDc62s(*args):
    """
    slaDc62s(double v, double a, double b, double r, double ad, 
        double bd, double rd)
    """
    return _slalib.slaDc62s(*args)

def slaDcc2s(*args):
    """slaDcc2s(double v, double a, double b)"""
    return _slalib.slaDcc2s(*args)

def slaDcmpf(*args):
    """
    slaDcmpf(double coeffs, double xz, double yz, double xs, double ys, 
        double perp, double orient)
    """
    return _slalib.slaDcmpf(*args)

def slaDcs2c(*args):
    """slaDcs2c(double a, double b, double v)"""
    return _slalib.slaDcs2c(*args)

def slaDd2tf(*args):
    """slaDd2tf(int ndp, double days, char sign, int ihmsf)"""
    return _slalib.slaDd2tf(*args)

def slaDe2h(*args):
    """slaDe2h(double ha, double dec, double phi, double az, double el)"""
    return _slalib.slaDe2h(*args)

def slaDeuler(*args):
    """slaDeuler(char order, double phi, double theta, double psi, double rmat)"""
    return _slalib.slaDeuler(*args)

def slaDfltin(*args):
    """slaDfltin(char string, int nstrt, double dreslt, int jflag)"""
    return _slalib.slaDfltin(*args)

def slaDh2e(*args):
    """slaDh2e(double az, double el, double phi, double ha, double dec)"""
    return _slalib.slaDh2e(*args)

def slaDimxv(*args):
    """slaDimxv(double dm, double va, double vb)"""
    return _slalib.slaDimxv(*args)

def slaDjcal(*args):
    """slaDjcal(int ndp, double djm, int iymdf, int j)"""
    return _slalib.slaDjcal(*args)

def slaDjcl(*args):
    """slaDjcl(double djm, int iy, int im, int id, double fd, int j)"""
    return _slalib.slaDjcl(*args)

def slaDm2av(*args):
    """slaDm2av(double rmat, double axvec)"""
    return _slalib.slaDm2av(*args)

def slaDmat(*args):
    """slaDmat(int n, double a, double y, double d, int jf, int iw)"""
    return _slalib.slaDmat(*args)

def slaDmoon(*args):
    """slaDmoon(double date, double pv)"""
    return _slalib.slaDmoon(*args)

def slaDmxm(*args):
    """slaDmxm(double a, double b, double c)"""
    return _slalib.slaDmxm(*args)

def slaDmxv(*args):
    """slaDmxv(double dm, double va, double vb)"""
    return _slalib.slaDmxv(*args)

def slaDpav(*args):
    """slaDpav(double v1, double v2) -> double"""
    return _slalib.slaDpav(*args)

def slaDr2af(*args):
    """slaDr2af(int ndp, double angle, char sign, int idmsf)"""
    return _slalib.slaDr2af(*args)

def slaDr2tf(*args):
    """slaDr2tf(int ndp, double angle, char sign, int ihmsf)"""
    return _slalib.slaDr2tf(*args)

def slaDrange(*args):
    """slaDrange(double angle) -> double"""
    return _slalib.slaDrange(*args)

def slaDranrm(*args):
    """slaDranrm(double angle) -> double"""
    return _slalib.slaDranrm(*args)

def slaDs2c6(*args):
    """
    slaDs2c6(double a, double b, double r, double ad, double bd, 
        double rd, double v)
    """
    return _slalib.slaDs2c6(*args)

def slaDs2tp(*args):
    """
    slaDs2tp(double ra, double dec, double raz, double decz, double xi, 
        double eta, int j)
    """
    return _slalib.slaDs2tp(*args)

def slaDsep(*args):
    """slaDsep(double a1, double b1, double a2, double b2) -> double"""
    return _slalib.slaDsep(*args)

def slaDsepv(*args):
    """slaDsepv(double v1, double v2) -> double"""
    return _slalib.slaDsepv(*args)

def slaDt(*args):
    """slaDt(double epoch) -> double"""
    return _slalib.slaDt(*args)

def slaDtf2d(*args):
    """slaDtf2d(int ihour, int imin, double sec, double days, int j)"""
    return _slalib.slaDtf2d(*args)

def slaDtf2r(*args):
    """slaDtf2r(int ihour, int imin, double sec, double rad, int j)"""
    return _slalib.slaDtf2r(*args)

def slaDtp2s(*args):
    """
    slaDtp2s(double xi, double eta, double raz, double decz, double ra, 
        double dec)
    """
    return _slalib.slaDtp2s(*args)

def slaDtp2v(*args):
    """slaDtp2v(double xi, double eta, double v0, double v)"""
    return _slalib.slaDtp2v(*args)

def slaDtps2c(*args):
    """
    slaDtps2c(double xi, double eta, double ra, double dec, double raz1, 
        double decz1, double raz2, double decz2, 
        int n)
    """
    return _slalib.slaDtps2c(*args)

def slaDtpv2c(*args):
    """
    slaDtpv2c(double xi, double eta, double v, double v01, double v02, 
        int n)
    """
    return _slalib.slaDtpv2c(*args)

def slaDtt(*args):
    """slaDtt(double dju) -> double"""
    return _slalib.slaDtt(*args)

def slaDv2tp(*args):
    """slaDv2tp(double v, double v0, double xi, double eta, int j)"""
    return _slalib.slaDv2tp(*args)

def slaDvdv(*args):
    """slaDvdv(double va, double vb) -> double"""
    return _slalib.slaDvdv(*args)

def slaDvn(*args):
    """slaDvn(double v, double uv, double vm)"""
    return _slalib.slaDvn(*args)

def slaDvxv(*args):
    """slaDvxv(double va, double vb, double vc)"""
    return _slalib.slaDvxv(*args)

def slaE2h(*args):
    """slaE2h(float ha, float dec, float phi, float az, float el)"""
    return _slalib.slaE2h(*args)

def slaEarth(*args):
    """slaEarth(int iy, int id, float fd, float posvel)"""
    return _slalib.slaEarth(*args)

def slaEcleq(*args):
    """slaEcleq(double dl, double db, double date, double dr, double dd)"""
    return _slalib.slaEcleq(*args)

def slaEcmat(*args):
    """slaEcmat(double date, double rmat)"""
    return _slalib.slaEcmat(*args)

def slaEcor(*args):
    """
    slaEcor(float rm, float dm, int iy, int id, float fd, float rv, 
        float tl)
    """
    return _slalib.slaEcor(*args)

def slaEg50(*args):
    """slaEg50(double dr, double dd, double dl, double db)"""
    return _slalib.slaEg50(*args)

def slaEl2ue(*args):
    """
    slaEl2ue(double date, int jform, double epoch, double orbinc, 
        double anode, double perih, double aorq, double e, 
        double aorl, double dm, double u, int jstat)
    """
    return _slalib.slaEl2ue(*args)

def slaEpb(*args):
    """slaEpb(double date) -> double"""
    return _slalib.slaEpb(*args)

def slaEpb2d(*args):
    """slaEpb2d(double epb) -> double"""
    return _slalib.slaEpb2d(*args)

def slaEpco(*args):
    """slaEpco(char k0, char k, double e) -> double"""
    return _slalib.slaEpco(*args)

def slaEpj(*args):
    """slaEpj(double date) -> double"""
    return _slalib.slaEpj(*args)

def slaEpj2d(*args):
    """slaEpj2d(double epj) -> double"""
    return _slalib.slaEpj2d(*args)

def slaEqecl(*args):
    """slaEqecl(double dr, double dd, double date, double dl, double db)"""
    return _slalib.slaEqecl(*args)

def slaEqeqx(*args):
    """slaEqeqx(double date) -> double"""
    return _slalib.slaEqeqx(*args)

def slaEqgal(*args):
    """slaEqgal(double dr, double dd, double dl, double db)"""
    return _slalib.slaEqgal(*args)

def slaEtrms(*args):
    """slaEtrms(double ep, double ev)"""
    return _slalib.slaEtrms(*args)

def slaEuler(*args):
    """slaEuler(char order, float phi, float theta, float psi, float rmat)"""
    return _slalib.slaEuler(*args)

def slaEvp(*args):
    """
    slaEvp(double date, double deqx, double dvb, double dpb, double dvh, 
        double dph)
    """
    return _slalib.slaEvp(*args)

def slaFitxy(*args):
    """
    slaFitxy(int itype, int np, double xye, double xym, double coeffs, 
        int j)
    """
    return _slalib.slaFitxy(*args)

def slaFk425(*args):
    """
    slaFk425(double r1950, double d1950, double dr1950, double dd1950, 
        double p1950, double v1950, double r2000, 
        double d2000, double dr2000, double dd2000, 
        double p2000, double v2000)
    """
    return _slalib.slaFk425(*args)

def slaFk45z(*args):
    """
    slaFk45z(double r1950, double d1950, double bepoch, double r2000, 
        double d2000)
    """
    return _slalib.slaFk45z(*args)

def slaFk524(*args):
    """
    slaFk524(double r2000, double d2000, double dr2000, double dd2000, 
        double p2000, double v2000, double r1950, 
        double d1950, double dr1950, double dd1950, 
        double p1950, double v1950)
    """
    return _slalib.slaFk524(*args)

def slaFk52h(*args):
    """
    slaFk52h(double r5, double d5, double dr5, double dd5, double dr, 
        double dh, double drh, double ddh)
    """
    return _slalib.slaFk52h(*args)

def slaFk54z(*args):
    """
    slaFk54z(double r2000, double d2000, double bepoch, double r1950, 
        double d1950, double dr1950, double dd1950)
    """
    return _slalib.slaFk54z(*args)

def slaFk5hz(*args):
    """slaFk5hz(double r5, double d5, double epoch, double rh, double dh)"""
    return _slalib.slaFk5hz(*args)

def slaFlotin(*args):
    """slaFlotin(char string, int nstrt, float reslt, int jflag)"""
    return _slalib.slaFlotin(*args)

def slaGaleq(*args):
    """slaGaleq(double dl, double db, double dr, double dd)"""
    return _slalib.slaGaleq(*args)

def slaGalsup(*args):
    """slaGalsup(double dl, double db, double dsl, double dsb)"""
    return _slalib.slaGalsup(*args)

def slaGe50(*args):
    """slaGe50(double dl, double db, double dr, double dd)"""
    return _slalib.slaGe50(*args)

def slaGeoc(*args):
    """slaGeoc(double p, double h, double r, double z)"""
    return _slalib.slaGeoc(*args)

def slaGmst(*args):
    """slaGmst(double ut1) -> double"""
    return _slalib.slaGmst(*args)

def slaGmsta(*args):
    """slaGmsta(double date, double ut1) -> double"""
    return _slalib.slaGmsta(*args)

def slaH2e(*args):
    """slaH2e(float az, float el, float phi, float ha, float dec)"""
    return _slalib.slaH2e(*args)

def slaH2fk5(*args):
    """
    slaH2fk5(double dr, double dh, double drh, double ddh, double r5, 
        double d5, double dr5, double dd5)
    """
    return _slalib.slaH2fk5(*args)

def slaHfk5z(*args):
    """
    slaHfk5z(double rh, double dh, double epoch, double r5, double d5, 
        double dr5, double dd5)
    """
    return _slalib.slaHfk5z(*args)

def slaImxv(*args):
    """slaImxv(float rm, float va, float vb)"""
    return _slalib.slaImxv(*args)

def slaIntin(*args):
    """slaIntin(char string, int nstrt, long ireslt, int jflag)"""
    return _slalib.slaIntin(*args)

def slaInvf(*args):
    """slaInvf(double fwds, double bkwds, int j)"""
    return _slalib.slaInvf(*args)

def slaKbj(*args):
    """slaKbj(int jb, double e, char k, int j)"""
    return _slalib.slaKbj(*args)

def slaM2av(*args):
    """slaM2av(float rmat, float axvec)"""
    return _slalib.slaM2av(*args)

def slaMap(*args):
    """
    slaMap(double rm, double dm, double pr, double pd, double px, 
        double rv, double eq, double date, double ra, 
        double da)
    """
    return _slalib.slaMap(*args)

def slaMappa(*args):
    """slaMappa(double eq, double date, double amprms)"""
    return _slalib.slaMappa(*args)

def slaMapqk(*args):
    """
    slaMapqk(double rm, double dm, double pr, double pd, double px, 
        double rv, double amprms, double ra, double da)
    """
    return _slalib.slaMapqk(*args)

def slaMapqkz(*args):
    """slaMapqkz(double rm, double dm, double amprms, double ra, double da)"""
    return _slalib.slaMapqkz(*args)

def slaMoon(*args):
    """slaMoon(int iy, int id, float fd, float posvel)"""
    return _slalib.slaMoon(*args)

def slaMxm(*args):
    """slaMxm(float a, float b, float c)"""
    return _slalib.slaMxm(*args)

def slaMxv(*args):
    """slaMxv(float rm, float va, float vb)"""
    return _slalib.slaMxv(*args)

def slaNut(*args):
    """slaNut(double date, double rmatn)"""
    return _slalib.slaNut(*args)

def slaNutc(*args):
    """slaNutc(double date, double dpsi, double deps, double eps0)"""
    return _slalib.slaNutc(*args)

def slaNutc80(*args):
    """slaNutc80(double date, double dpsi, double deps, double eps0)"""
    return _slalib.slaNutc80(*args)

def slaOap(*args):
    """
    slaOap(char type, double ob1, double ob2, double date, double dut, 
        double elongm, double phim, double hm, 
        double xp, double yp, double tdk, double pmb, 
        double rh, double wl, double tlr, double rap, 
        double dap)
    """
    return _slalib.slaOap(*args)

def slaOapqk(*args):
    """
    slaOapqk(char type, double ob1, double ob2, double aoprms, double rap, 
        double dap)
    """
    return _slalib.slaOapqk(*args)

def slaObs(*args):
    """slaObs(int n, char c, char name, double w, double p, double h)"""
    return _slalib.slaObs(*args)

def slaPa(*args):
    """slaPa(double ha, double dec, double phi) -> double"""
    return _slalib.slaPa(*args)

def slaPav(*args):
    """slaPav(float v1, float v2) -> double"""
    return _slalib.slaPav(*args)

def slaPcd(*args):
    """slaPcd(double disco, double x, double y)"""
    return _slalib.slaPcd(*args)

def slaPda2h(*args):
    """
    slaPda2h(double p, double d, double a, double h1, int j1, double h2, 
        int j2)
    """
    return _slalib.slaPda2h(*args)

def slaPdq2h(*args):
    """
    slaPdq2h(double p, double d, double q, double h1, int j1, double h2, 
        int j2)
    """
    return _slalib.slaPdq2h(*args)

def slaPermut(*args):
    """slaPermut(int n, int istate, int iorder, int j)"""
    return _slalib.slaPermut(*args)

def slaPertel(*args):
    """
    slaPertel(int jform, double date0, double date1, double epoch0, 
        double orbi0, double anode0, double perih0, 
        double aorq0, double e0, double am0, double epoch1, 
        double orbi1, double anode1, double perih1, 
        double aorq1, double e1, double am1, 
        int jstat)
    """
    return _slalib.slaPertel(*args)

def slaPertue(*args):
    """slaPertue(double date, double u, int jstat)"""
    return _slalib.slaPertue(*args)

def slaPlanel(*args):
    """
    slaPlanel(double date, int jform, double epoch, double orbinc, 
        double anode, double perih, double aorq, double e, 
        double aorl, double dm, double pv, int jstat)
    """
    return _slalib.slaPlanel(*args)

def slaPlanet(*args):
    """slaPlanet(double date, int np, double pv, int j)"""
    return _slalib.slaPlanet(*args)

def slaPlante(*args):
    """
    slaPlante(double date, double elong, double phi, int jform, double epoch, 
        double orbinc, double anode, double perih, 
        double aorq, double e, double aorl, 
        double dm, double ra, double dec, double r, 
        int jstat)
    """
    return _slalib.slaPlante(*args)

def slaPm(*args):
    """
    slaPm(double r0, double d0, double pr, double pd, double px, 
        double rv, double ep0, double ep1, double r1, 
        double d1)
    """
    return _slalib.slaPm(*args)

def slaPolmo(*args):
    """
    slaPolmo(double elongm, double phim, double xp, double yp, double elong, 
        double phi, double daz)
    """
    return _slalib.slaPolmo(*args)

def slaPrebn(*args):
    """slaPrebn(double bep0, double bep1, double rmatp)"""
    return _slalib.slaPrebn(*args)

def slaPrec(*args):
    """slaPrec(double ep0, double ep1, double rmatp)"""
    return _slalib.slaPrec(*args)

def slaPrecl(*args):
    """slaPrecl(double ep0, double ep1, double rmatp)"""
    return _slalib.slaPrecl(*args)

def slaPreces(*args):
    """slaPreces(char sys, double ep0, double ep1, double ra, double dc)"""
    return _slalib.slaPreces(*args)

def slaPrenut(*args):
    """slaPrenut(double epoch, double date, double rmatpn)"""
    return _slalib.slaPrenut(*args)

def slaPv2el(*args):
    """
    slaPv2el(double pv, double date, double pmass, int jformr, int jform, 
        double epoch, double orbinc, double anode, 
        double perih, double aorq, double e, 
        double aorl, double dm, int jstat)
    """
    return _slalib.slaPv2el(*args)

def slaPv2ue(*args):
    """slaPv2ue(double pv, double date, double pmass, double u, int jstat)"""
    return _slalib.slaPv2ue(*args)

def slaPvobs(*args):
    """slaPvobs(double p, double h, double stl, double pv)"""
    return _slalib.slaPvobs(*args)

def slaPxy(*args):
    """
    slaPxy(int np, double xye, double xym, double coeffs, double xyp, 
        double xrms, double yrms, double rrms)
    """
    return _slalib.slaPxy(*args)

def slaRange(*args):
    """slaRange(float angle) -> float"""
    return _slalib.slaRange(*args)

def slaRanorm(*args):
    """slaRanorm(float angle) -> float"""
    return _slalib.slaRanorm(*args)

def slaRcc(*args):
    """slaRcc(double tdb, double ut1, double wl, double u, double v) -> double"""
    return _slalib.slaRcc(*args)

def slaRdplan(*args):
    """
    slaRdplan(double date, int np, double elong, double phi, double ra, 
        double dec, double diam)
    """
    return _slalib.slaRdplan(*args)

def slaRefco(*args):
    """
    slaRefco(double hm, double tdk, double pmb, double rh, double wl, 
        double phi, double tlr, double eps, double refa, 
        double refb)
    """
    return _slalib.slaRefco(*args)

def slaRefcoq(*args):
    """
    slaRefcoq(double tdk, double pmb, double rh, double wl, double refa, 
        double refb)
    """
    return _slalib.slaRefcoq(*args)

def slaRefro(*args):
    """
    slaRefro(double zobs, double hm, double tdk, double pmb, double rh, 
        double wl, double phi, double tlr, double eps, 
        double ref)
    """
    return _slalib.slaRefro(*args)

def slaRefv(*args):
    """slaRefv(double vu, double refa, double refb, double vr)"""
    return _slalib.slaRefv(*args)

def slaRefz(*args):
    """slaRefz(double zu, double refa, double refb, double zr)"""
    return _slalib.slaRefz(*args)

def slaRverot(*args):
    """slaRverot(float phi, float ra, float da, float st) -> float"""
    return _slalib.slaRverot(*args)

def slaRvgalc(*args):
    """slaRvgalc(float r2000, float d2000) -> float"""
    return _slalib.slaRvgalc(*args)

def slaRvlg(*args):
    """slaRvlg(float r2000, float d2000) -> float"""
    return _slalib.slaRvlg(*args)

def slaRvlsrd(*args):
    """slaRvlsrd(float r2000, float d2000) -> float"""
    return _slalib.slaRvlsrd(*args)

def slaRvlsrk(*args):
    """slaRvlsrk(float r2000, float d2000) -> float"""
    return _slalib.slaRvlsrk(*args)

def slaS2tp(*args):
    """
    slaS2tp(float ra, float dec, float raz, float decz, float xi, 
        float eta, int j)
    """
    return _slalib.slaS2tp(*args)

def slaSep(*args):
    """slaSep(float a1, float b1, float a2, float b2) -> float"""
    return _slalib.slaSep(*args)

def slaSepv(*args):
    """slaSepv(float v1, float v2) -> float"""
    return _slalib.slaSepv(*args)

def slaSmat(*args):
    """slaSmat(int n, float a, float y, float d, int jf, int iw)"""
    return _slalib.slaSmat(*args)

def slaSubet(*args):
    """slaSubet(double rc, double dc, double eq, double rm, double dm)"""
    return _slalib.slaSubet(*args)

def slaSupgal(*args):
    """slaSupgal(double dsl, double dsb, double dl, double db)"""
    return _slalib.slaSupgal(*args)

def slaSvd(*args):
    """
    slaSvd(int m, int n, int mp, int np, double a, double w, double v, 
        double work, int jstat)
    """
    return _slalib.slaSvd(*args)

def slaSvdcov(*args):
    """
    slaSvdcov(int n, int np, int nc, double w, double v, double work, 
        double cvm)
    """
    return _slalib.slaSvdcov(*args)

def slaSvdsol(*args):
    """
    slaSvdsol(int m, int n, int mp, int np, double b, double u, double w, 
        double v, double work, double x)
    """
    return _slalib.slaSvdsol(*args)

def slaTp2s(*args):
    """
    slaTp2s(float xi, float eta, float raz, float decz, float ra, 
        float dec)
    """
    return _slalib.slaTp2s(*args)

def slaTp2v(*args):
    """slaTp2v(float xi, float eta, float v0, float v)"""
    return _slalib.slaTp2v(*args)

def slaTps2c(*args):
    """
    slaTps2c(float xi, float eta, float ra, float dec, float raz1, 
        float decz1, float raz2, float decz2, int n)
    """
    return _slalib.slaTps2c(*args)

def slaTpv2c(*args):
    """
    slaTpv2c(float xi, float eta, float v, float v01, float v02, 
        int n)
    """
    return _slalib.slaTpv2c(*args)

def slaUe2el(*args):
    """
    slaUe2el(double u, int jformr, int jform, double epoch, double orbinc, 
        double anode, double perih, double aorq, 
        double e, double aorl, double dm, int jstat)
    """
    return _slalib.slaUe2el(*args)

def slaUe2pv(*args):
    """slaUe2pv(double date, double u, double pv, int jstat)"""
    return _slalib.slaUe2pv(*args)

def slaUnpcd(*args):
    """slaUnpcd(double disco, double x, double y)"""
    return _slalib.slaUnpcd(*args)

def slaV2tp(*args):
    """slaV2tp(float v, float v0, float xi, float eta, int j)"""
    return _slalib.slaV2tp(*args)

def slaVdv(*args):
    """slaVdv(float va, float vb) -> float"""
    return _slalib.slaVdv(*args)

def slaVn(*args):
    """slaVn(float v, float uv, float vm)"""
    return _slalib.slaVn(*args)

def slaVxv(*args):
    """slaVxv(float va, float vb, float vc)"""
    return _slalib.slaVxv(*args)

def slaXy2xy(*args):
    """slaXy2xy(double x1, double y1, double coeffs, double x2, double y2)"""
    return _slalib.slaXy2xy(*args)

def slaZd(*args):
    """slaZd(double ha, double dec, double phi) -> double"""
    return _slalib.slaZd(*args)