# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _cspyce0
else:
    import _cspyce0

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)



def axisar(axis, angle):
    r"""axisar(ConstSpiceDouble [3] axis, SpiceDouble angle)"""
    return _cspyce0.axisar(axis, angle)

def axisar_vector(in21, in11):
    r"""axisar_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11)"""
    return _cspyce0.axisar_vector(in21, in11)

def b1900():
    r"""b1900() -> SpiceDouble"""
    return _cspyce0.b1900()

def b1950():
    r"""b1950() -> SpiceDouble"""
    return _cspyce0.b1950()

def bltfrm(frmcls):
    r"""bltfrm(SpiceInt frmcls)"""
    return _cspyce0.bltfrm(frmcls)

def bodc2n(code):
    r"""bodc2n(SpiceInt code)"""
    return _cspyce0.bodc2n(code)

def bodc2s(code):
    r"""bodc2s(SpiceInt code)"""
    return _cspyce0.bodc2s(code)

def boddef(CONST_STRING, code):
    r"""boddef(ConstSpiceChar * CONST_STRING, SpiceInt code)"""
    return _cspyce0.boddef(CONST_STRING, code)

def bodfnd(body, CONST_STRING):
    r"""bodfnd(SpiceInt body, ConstSpiceChar * CONST_STRING) -> SpiceBoolean"""
    return _cspyce0.bodfnd(body, CONST_STRING)

def bodn2c(CONST_STRING):
    r"""bodn2c(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.bodn2c(CONST_STRING)

def bods2c(CONST_STRING):
    r"""bods2c(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.bods2c(CONST_STRING)

def bodvar(body, CONST_STRING):
    r"""bodvar(SpiceInt body, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.bodvar(body, CONST_STRING)

def bodvcd(bodyid, CONST_STRING):
    r"""bodvcd(SpiceInt bodyid, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.bodvcd(bodyid, CONST_STRING)

def bodvrd(arg1, arg2):
    r"""bodvrd(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"""
    return _cspyce0.bodvrd(arg1, arg2)

def ccifrm(frclss, clssid):
    r"""ccifrm(SpiceInt frclss, SpiceInt clssid)"""
    return _cspyce0.ccifrm(frclss, clssid)

def cgv2el(center, vec1, vec2):
    r"""cgv2el(ConstSpiceDouble [3] center, ConstSpiceDouble [3] vec1, ConstSpiceDouble [3] vec2)"""
    return _cspyce0.cgv2el(center, vec1, vec2)

def cgv2el_vector(in21, in22, in23):
    r"""cgv2el_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"""
    return _cspyce0.cgv2el_vector(in21, in22, in23)

def chkin(CONST_STRING):
    r"""chkin(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.chkin(CONST_STRING)

def chkout(CONST_STRING):
    r"""chkout(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.chkout(CONST_STRING)

def cidfrm(cent):
    r"""cidfrm(SpiceInt cent)"""
    return _cspyce0.cidfrm(cent)

def ckcov(ck, idcode, needav, level, tol, timsys):
    r"""ckcov(ConstSpiceChar * ck, SpiceInt idcode, SpiceBoolean needav, ConstSpiceChar * level, SpiceDouble tol, ConstSpiceChar * timsys)"""
    return _cspyce0.ckcov(ck, idcode, needav, level, tol, timsys)

def ckgp(inst, sclkdp, tol, CONST_STRING):
    r"""ckgp(SpiceInt inst, SpiceDouble sclkdp, SpiceDouble tol, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.ckgp(inst, sclkdp, tol, CONST_STRING)

def ckgp_vector(k1, in11, in12, str1):
    r"""ckgp_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceChar * str1)"""
    return _cspyce0.ckgp_vector(k1, in11, in12, str1)

def ckgpav(inst, sclkdp, tol, CONST_STRING):
    r"""ckgpav(SpiceInt inst, SpiceDouble sclkdp, SpiceDouble tol, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.ckgpav(inst, sclkdp, tol, CONST_STRING)

def ckgpav_vector(k1, in11, in12, str1):
    r"""ckgpav_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceChar * str1)"""
    return _cspyce0.ckgpav_vector(k1, in11, in12, str1)

def ckobj(ck):
    r"""ckobj(ConstSpiceChar * ck)"""
    return _cspyce0.ckobj(ck)

def clight():
    r"""clight() -> SpiceDouble"""
    return _cspyce0.clight()

def clpool():
    r"""clpool()"""
    return _cspyce0.clpool()

def cnmfrm(cname):
    r"""cnmfrm(ConstSpiceChar * cname)"""
    return _cspyce0.cnmfrm(cname)

def conics(elts, et):
    r"""conics(ConstSpiceDouble [8] elts, SpiceDouble et)"""
    return _cspyce0.conics(elts, et)

def conics_vector(in21, in11):
    r"""conics_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11)"""
    return _cspyce0.conics_vector(in21, in11)

def convrt(x, arg2, arg3):
    r"""convrt(SpiceDouble x, ConstSpiceChar * arg2, ConstSpiceChar * arg3)"""
    return _cspyce0.convrt(x, arg2, arg3)

def convrt_vector(in11, str1, str2):
    r"""convrt_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2)"""
    return _cspyce0.convrt_vector(in11, str1, str2)

def cyllat(r, lonc, z):
    r"""cyllat(SpiceDouble r, SpiceDouble lonc, SpiceDouble z)"""
    return _cspyce0.cyllat(r, lonc, z)

def cyllat_vector(in11, in12, in13):
    r"""cyllat_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.cyllat_vector(in11, in12, in13)

def cylrec(r, lon, z):
    r"""cylrec(SpiceDouble r, SpiceDouble lon, SpiceDouble z)"""
    return _cspyce0.cylrec(r, lon, z)

def cylrec_vector(in11, in12, in13):
    r"""cylrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.cylrec_vector(in11, in12, in13)

def cylsph(r, lonc, z):
    r"""cylsph(SpiceDouble r, SpiceDouble lonc, SpiceDouble z)"""
    return _cspyce0.cylsph(r, lonc, z)

def cylsph_vector(in11, in12, in13):
    r"""cylsph_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.cylsph_vector(in11, in12, in13)

def dafbfs(handle):
    r"""dafbfs(SpiceInt handle)"""
    return _cspyce0.dafbfs(handle)

def dafcls(handle):
    r"""dafcls(SpiceInt handle)"""
    return _cspyce0.dafcls(handle)

def dafgda(handle, begin, end):
    r"""dafgda(SpiceInt handle, SpiceInt begin, SpiceInt end)"""
    return _cspyce0.dafgda(handle, begin, end)

def dafgn():
    r"""dafgn()"""
    return _cspyce0.dafgn()

def dafgs():
    r"""dafgs()"""
    return _cspyce0.dafgs()

def daffna():
    r"""daffna()"""
    return _cspyce0.daffna()

def dafopr(CONST_STRING):
    r"""dafopr(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.dafopr(CONST_STRING)

def dafus(sum, nd, ni):
    r"""dafus(ConstSpiceDouble [DAFSIZE] sum, SpiceInt nd, SpiceInt ni)"""
    return _cspyce0.dafus(sum, nd, ni)

def dcyldr(x, y, z):
    r"""dcyldr(SpiceDouble x, SpiceDouble y, SpiceDouble z)"""
    return _cspyce0.dcyldr(x, y, z)

def dcyldr_vector(in11, in12, in13):
    r"""dcyldr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.dcyldr_vector(in11, in12, in13)

def deltet(epoch, CONST_STRING):
    r"""deltet(SpiceDouble epoch, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.deltet(epoch, CONST_STRING)

def deltet_vector(in11, str1):
    r"""deltet_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1)"""
    return _cspyce0.deltet_vector(in11, str1)

def det(m1):
    r"""det(ConstSpiceDouble [3][3] m1) -> SpiceDouble"""
    return _cspyce0.det(m1)

def det_vector(in31):
    r"""det_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.det_vector(in31)

def dgeodr(x, y, z, re, f):
    r"""dgeodr(SpiceDouble x, SpiceDouble y, SpiceDouble z, SpiceDouble re, SpiceDouble f)"""
    return _cspyce0.dgeodr(x, y, z, re, f)

def dgeodr_vector(in11, in12, in13, in14, in15):
    r"""dgeodr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"""
    return _cspyce0.dgeodr_vector(in11, in12, in13, in14, in15)

def diags2(symmat):
    r"""diags2(ConstSpiceDouble [2][2] symmat)"""
    return _cspyce0.diags2(symmat)

def diags2_vector(in31):
    r"""diags2_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.diags2_vector(in31)

def dlatdr(x, y, z):
    r"""dlatdr(SpiceDouble x, SpiceDouble y, SpiceDouble z)"""
    return _cspyce0.dlatdr(x, y, z)

def dlatdr_vector(in11, in12, in13):
    r"""dlatdr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.dlatdr_vector(in11, in12, in13)

def dpgrdr(CONST_STRING, x, y, z, re, f):
    r"""dpgrdr(ConstSpiceChar * CONST_STRING, SpiceDouble x, SpiceDouble y, SpiceDouble z, SpiceDouble re, SpiceDouble f)"""
    return _cspyce0.dpgrdr(CONST_STRING, x, y, z, re, f)

def dpgrdr_vector(str1, in11, in12, in13, in14, in15):
    r"""dpgrdr_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"""
    return _cspyce0.dpgrdr_vector(str1, in11, in12, in13, in14, in15)

def dpmax():
    r"""dpmax() -> SpiceDouble"""
    return _cspyce0.dpmax()

def dpmin():
    r"""dpmin() -> SpiceDouble"""
    return _cspyce0.dpmin()

def dpr():
    r"""dpr() -> SpiceDouble"""
    return _cspyce0.dpr()

def drdcyl(r, lon, z):
    r"""drdcyl(SpiceDouble r, SpiceDouble lon, SpiceDouble z)"""
    return _cspyce0.drdcyl(r, lon, z)

def drdcyl_vector(in11, in12, in13):
    r"""drdcyl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.drdcyl_vector(in11, in12, in13)

def drdgeo(lon, lat, alt, re, f):
    r"""drdgeo(SpiceDouble lon, SpiceDouble lat, SpiceDouble alt, SpiceDouble re, SpiceDouble f)"""
    return _cspyce0.drdgeo(lon, lat, alt, re, f)

def drdgeo_vector(in11, in12, in13, in14, in15):
    r"""drdgeo_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"""
    return _cspyce0.drdgeo_vector(in11, in12, in13, in14, in15)

def drdlat(r, lon, lat):
    r"""drdlat(SpiceDouble r, SpiceDouble lon, SpiceDouble lat)"""
    return _cspyce0.drdlat(r, lon, lat)

def drdlat_vector(in11, in12, in13):
    r"""drdlat_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.drdlat_vector(in11, in12, in13)

def drdpgr(CONST_STRING, lon, lat, alt, re, f):
    r"""drdpgr(ConstSpiceChar * CONST_STRING, SpiceDouble lon, SpiceDouble lat, SpiceDouble alt, SpiceDouble re, SpiceDouble f)"""
    return _cspyce0.drdpgr(CONST_STRING, lon, lat, alt, re, f)

def drdpgr_vector(str1, in11, in12, in13, in14, in15):
    r"""drdpgr_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"""
    return _cspyce0.drdpgr_vector(str1, in11, in12, in13, in14, in15)

def drdsph(r, colat, lon):
    r"""drdsph(SpiceDouble r, SpiceDouble colat, SpiceDouble lon)"""
    return _cspyce0.drdsph(r, colat, lon)

def drdsph_vector(in11, in12, in13):
    r"""drdsph_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.drdsph_vector(in11, in12, in13)

def dsphdr(x, y, z):
    r"""dsphdr(SpiceDouble x, SpiceDouble y, SpiceDouble z)"""
    return _cspyce0.dsphdr(x, y, z)

def dsphdr_vector(in11, in12, in13):
    r"""dsphdr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.dsphdr_vector(in11, in12, in13)

def dtpool(CONST_STRING):
    r"""dtpool(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.dtpool(CONST_STRING)

def ducrss(s1, s2):
    r"""ducrss(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2)"""
    return _cspyce0.ducrss(s1, s2)

def ducrss_vector(in21, in22):
    r"""ducrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.ducrss_vector(in21, in22)

def dvcrss(s1, s2):
    r"""dvcrss(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2)"""
    return _cspyce0.dvcrss(s1, s2)

def dvcrss_vector(in21, in22):
    r"""dvcrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.dvcrss_vector(in21, in22)

def dvdot(s1, s2):
    r"""dvdot(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2) -> SpiceDouble"""
    return _cspyce0.dvdot(s1, s2)

def dvdot_vector(in21, in22):
    r"""dvdot_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.dvdot_vector(in21, in22)

def dvhat(s1):
    r"""dvhat(ConstSpiceDouble [6] s1)"""
    return _cspyce0.dvhat(s1)

def dvhat_vector(in21):
    r"""dvhat_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.dvhat_vector(in21)

def dvnorm(state):
    r"""dvnorm(ConstSpiceDouble [6] state) -> SpiceDouble"""
    return _cspyce0.dvnorm(state)

def dvnorm_vector(in21):
    r"""dvnorm_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.dvnorm_vector(in21)

def dvpool(CONST_STRING):
    r"""dvpool(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.dvpool(CONST_STRING)

def dvsep(s1, s2):
    r"""dvsep(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2) -> SpiceDouble"""
    return _cspyce0.dvsep(s1, s2)

def dvsep_vector(in21, in22):
    r"""dvsep_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.dvsep_vector(in21, in22)

def edlimb(a, b, c, viewpt):
    r"""edlimb(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [3] viewpt)"""
    return _cspyce0.edlimb(a, b, c, viewpt)

def edlimb_vector(in11, in12, in13, in21):
    r"""edlimb_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in21)"""
    return _cspyce0.edlimb_vector(in11, in12, in13, in21)

def edterm(trmtyp, source, target, et, fixref, abcorr, obsrvr, npts):
    r"""edterm(ConstSpiceChar * trmtyp, ConstSpiceChar * source, ConstSpiceChar * target, SpiceDouble et, ConstSpiceChar * fixref, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceInt npts)"""
    return _cspyce0.edterm(trmtyp, source, target, et, fixref, abcorr, obsrvr, npts)

def el2cgv(ellipse):
    r"""el2cgv(ConstSpiceDouble [NELLIPSE] ellipse)"""
    return _cspyce0.el2cgv(ellipse)

def el2cgv_vector(in21):
    r"""el2cgv_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.el2cgv_vector(in21)

def eqncpv(et, epoch, eqel, rapol, decpol):
    r"""eqncpv(SpiceDouble et, SpiceDouble epoch, ConstSpiceDouble [9] eqel, SpiceDouble rapol, SpiceDouble decpol)"""
    return _cspyce0.eqncpv(et, epoch, eqel, rapol, decpol)

def eqncpv_vector(in11, in12, in21, in13, in14):
    r"""eqncpv_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in21, ConstSpiceDouble * in13, ConstSpiceDouble * in14)"""
    return _cspyce0.eqncpv_vector(in11, in12, in21, in13, in14)

def erract(op, lenout):
    r"""erract(ConstSpiceChar * op, SpiceInt lenout)"""
    return _cspyce0.erract(op, lenout)

def errch(arg1, arg2):
    r"""errch(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"""
    return _cspyce0.errch(arg1, arg2)

def errdev(CONST_STRING, lenout):
    r"""errdev(ConstSpiceChar * CONST_STRING, SpiceInt lenout)"""
    return _cspyce0.errdev(CONST_STRING, lenout)

def errdp(CONST_STRING, number):
    r"""errdp(ConstSpiceChar * CONST_STRING, SpiceDouble number)"""
    return _cspyce0.errdp(CONST_STRING, number)

def errint(CONST_STRING, number):
    r"""errint(ConstSpiceChar * CONST_STRING, SpiceInt number)"""
    return _cspyce0.errint(CONST_STRING, number)

def errprt(CONST_STRING, lenout):
    r"""errprt(ConstSpiceChar * CONST_STRING, SpiceInt lenout)"""
    return _cspyce0.errprt(CONST_STRING, lenout)

def et2lst(et, body, lon, type):
    r"""et2lst(SpiceDouble et, SpiceInt body, SpiceDouble lon, ConstSpiceChar * type)"""
    return _cspyce0.et2lst(et, body, lon, type)

def et2utc(et, CONST_STRING, prec):
    r"""et2utc(SpiceDouble et, ConstSpiceChar * CONST_STRING, SpiceInt prec)"""
    return _cspyce0.et2utc(et, CONST_STRING, prec)

def etcal(et):
    r"""etcal(SpiceDouble et)"""
    return _cspyce0.etcal(et)

def eul2m(angle3, angle2, angle1, axis3, axis2, axis1):
    r"""eul2m(SpiceDouble angle3, SpiceDouble angle2, SpiceDouble angle1, SpiceInt axis3, SpiceInt axis2, SpiceInt axis1)"""
    return _cspyce0.eul2m(angle3, angle2, angle1, axis3, axis2, axis1)

def eul2m_vector(in11, in12, in13, k1, k2, k3):
    r"""eul2m_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, SpiceInt k1, SpiceInt k2, SpiceInt k3)"""
    return _cspyce0.eul2m_vector(in11, in12, in13, k1, k2, k3)

def eul2xf(eulang, axisa, axisb, axisc):
    r"""eul2xf(ConstSpiceDouble [6] eulang, SpiceInt axisa, SpiceInt axisb, SpiceInt axisc)"""
    return _cspyce0.eul2xf(eulang, axisa, axisb, axisc)

def eul2xf_vector(in21, k1, k2, k3):
    r"""eul2xf_vector(ConstSpiceDouble * in21, SpiceInt k1, SpiceInt k2, SpiceInt k3)"""
    return _cspyce0.eul2xf_vector(in21, k1, k2, k3)

def expool(CONST_STRING):
    r"""expool(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.expool(CONST_STRING)

def failed():
    r"""failed() -> SpiceBoolean"""
    return _cspyce0.failed()

def fovray(inst, raydir, rframe, abcorr, obsrvr, et, visibl):
    r"""fovray(ConstSpiceChar * inst, ConstSpiceDouble [3] raydir, ConstSpiceChar * rframe, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceDouble et, SpiceBoolean * visibl)"""
    return _cspyce0.fovray(inst, raydir, rframe, abcorr, obsrvr, et, visibl)

def fovray_vector(str1, in21, str2, str3, str4, in11):
    r"""fovray_vector(ConstSpiceChar * str1, ConstSpiceDouble * in21, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceDouble * in11)"""
    return _cspyce0.fovray_vector(str1, in21, str2, str3, str4, in11)

def fovtrg(inst, target, tshape, tframe, abcorr, obsrvr, et, visibl):
    r"""fovtrg(ConstSpiceChar * inst, ConstSpiceChar * target, ConstSpiceChar * tshape, ConstSpiceChar * tframe, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceDouble et, SpiceBoolean * visibl)"""
    return _cspyce0.fovtrg(inst, target, tshape, tframe, abcorr, obsrvr, et, visibl)

def fovtrg_vector(str1, str2, str3, str4, str5, str6, in11):
    r"""fovtrg_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceDouble * in11)"""
    return _cspyce0.fovtrg_vector(str1, str2, str3, str4, str5, str6, in11)

def frame(x1):
    r"""frame(ConstSpiceDouble [3] x1)"""
    return _cspyce0.frame(x1)

def frame_vector(in21):
    r"""frame_vector(SpiceDouble * in21)"""
    return _cspyce0.frame_vector(in21)

def frinfo(frcode):
    r"""frinfo(SpiceInt frcode)"""
    return _cspyce0.frinfo(frcode)

def frmchg(frame1, frame2, et):
    r"""frmchg(SpiceInt frame1, SpiceInt frame2, SpiceDouble et)"""
    return _cspyce0.frmchg(frame1, frame2, et)

def frmchg_(frame1, frame2, et, xform):
    r"""frmchg_(SpiceInt * frame1, SpiceInt * frame2, SpiceDouble * et, SpiceDouble * xform)"""
    return _cspyce0.frmchg_(frame1, frame2, et, xform)

def frmchg_vector(k1, k2, in11):
    r"""frmchg_vector(SpiceInt k1, SpiceInt k2, ConstSpiceDouble * in11)"""
    return _cspyce0.frmchg_vector(k1, k2, in11)

def frmnam(frcode):
    r"""frmnam(SpiceInt frcode)"""
    return _cspyce0.frmnam(frcode)

def furnsh(CONST_STRING):
    r"""furnsh(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.furnsh(CONST_STRING)

def gcpool(CONST_STRING, start):
    r"""gcpool(ConstSpiceChar * CONST_STRING, SpiceInt start)"""
    return _cspyce0.gcpool(CONST_STRING, start)

def gdpool(CONST_STRING, start):
    r"""gdpool(ConstSpiceChar * CONST_STRING, SpiceInt start)"""
    return _cspyce0.gdpool(CONST_STRING, start)

def georec(lon, lat, alt, re, f):
    r"""georec(SpiceDouble lon, SpiceDouble lat, SpiceDouble alt, SpiceDouble re, SpiceDouble f)"""
    return _cspyce0.georec(lon, lat, alt, re, f)

def georec_vector(in11, in12, in13, in14, in15):
    r"""georec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"""
    return _cspyce0.georec_vector(in11, in12, in13, in14, in15)

def getfov(instid):
    r"""getfov(SpiceInt instid)"""
    return _cspyce0.getfov(instid)

def getmsg(option):
    r"""getmsg(ConstSpiceChar * option)"""
    return _cspyce0.getmsg(option)

def gipool(CONST_STRING, start):
    r"""gipool(ConstSpiceChar * CONST_STRING, SpiceInt start)"""
    return _cspyce0.gipool(CONST_STRING, start)

def gnpool(CONST_STRING, start):
    r"""gnpool(ConstSpiceChar * CONST_STRING, SpiceInt start)"""
    return _cspyce0.gnpool(CONST_STRING, start)

def halfpi():
    r"""halfpi() -> SpiceDouble"""
    return _cspyce0.halfpi()

def ident():
    r"""ident()"""
    return _cspyce0.ident()

def illum(arg1, et, arg3, arg4, spoint):
    r"""illum(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceDouble [3] spoint)"""
    return _cspyce0.illum(arg1, et, arg3, arg4, spoint)

def illum_vector(str1, in11, str2, str3, in21):
    r"""illum_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceDouble * in21)"""
    return _cspyce0.illum_vector(str1, in11, str2, str3, in21)

def illumf(arg1, arg2, arg3, et, arg5, arg6, arg7, spoint):
    r"""illumf(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceDouble et, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceDouble [3] spoint)"""
    return _cspyce0.illumf(arg1, arg2, arg3, et, arg5, arg6, arg7, spoint)

def illumf_vector(str1, str2, str3, in11, str4, str5, str6, in21):
    r"""illumf_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceDouble * in11, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceDouble * in21)"""
    return _cspyce0.illumf_vector(str1, str2, str3, in11, str4, str5, str6, in21)

def illumg(arg1, arg2, arg3, et, arg5, arg6, arg7, spoint):
    r"""illumg(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceDouble et, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceDouble [3] spoint)"""
    return _cspyce0.illumg(arg1, arg2, arg3, et, arg5, arg6, arg7, spoint)

def illumg_vector(str1, str2, str3, in11, str4, str5, str6, in21):
    r"""illumg_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceDouble * in11, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceDouble * in21)"""
    return _cspyce0.illumg_vector(str1, str2, str3, in11, str4, str5, str6, in21)

def ilumin(arg1, arg2, et, arg4, arg5, arg6, spoint):
    r"""ilumin(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceDouble [3] spoint)"""
    return _cspyce0.ilumin(arg1, arg2, et, arg4, arg5, arg6, spoint)

def ilumin_vector(str1, str2, in11, str3, str4, str5, in21):
    r"""ilumin_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceDouble * in21)"""
    return _cspyce0.ilumin_vector(str1, str2, in11, str3, str4, str5, in21)

def inedpl(a, b, c, plane):
    r"""inedpl(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [NPLANE] plane)"""
    return _cspyce0.inedpl(a, b, c, plane)

def inedpl_vector(in11, in12, in13, in21):
    r"""inedpl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in21)"""
    return _cspyce0.inedpl_vector(in11, in12, in13, in21)

def inelpl(ellips, plane):
    r"""inelpl(ConstSpiceDouble [NELLIPSE] ellips, ConstSpiceDouble [NPLANE] plane)"""
    return _cspyce0.inelpl(ellips, plane)

def inelpl_vector(in21, in22):
    r"""inelpl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.inelpl_vector(in21, in22)

def inrypl(vertex, dir, plane):
    r"""inrypl(ConstSpiceDouble [3] vertex, ConstSpiceDouble [3] dir, ConstSpiceDouble [NPLANE] plane)"""
    return _cspyce0.inrypl(vertex, dir, plane)

def inrypl_vector(in21, in22, in23):
    r"""inrypl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"""
    return _cspyce0.inrypl_vector(in21, in22, in23)

def intmax():
    r"""intmax() -> SpiceInt"""
    return _cspyce0.intmax()

def intmin():
    r"""intmin() -> SpiceInt"""
    return _cspyce0.intmin()

def invert(m1):
    r"""invert(ConstSpiceDouble [3][3] m1)"""
    return _cspyce0.invert(m1)

def invert_vector(in31):
    r"""invert_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.invert_vector(in31)

def invort(m):
    r"""invort(ConstSpiceDouble [3][3] m)"""
    return _cspyce0.invort(m)

def invort_vector(in31):
    r"""invort_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.invort_vector(in31)

def isrot(m, ntol, dtol):
    r"""isrot(ConstSpiceDouble [3][3] m, SpiceDouble ntol, SpiceDouble dtol) -> SpiceBoolean"""
    return _cspyce0.isrot(m, ntol, dtol)

def isrot_vector(in31, in11, in12):
    r"""isrot_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
    return _cspyce0.isrot_vector(in31, in11, in12)

def j1900():
    r"""j1900() -> SpiceDouble"""
    return _cspyce0.j1900()

def j1950():
    r"""j1950() -> SpiceDouble"""
    return _cspyce0.j1950()

def j2000():
    r"""j2000() -> SpiceDouble"""
    return _cspyce0.j2000()

def j2100():
    r"""j2100() -> SpiceDouble"""
    return _cspyce0.j2100()

def jyear():
    r"""jyear() -> SpiceDouble"""
    return _cspyce0.jyear()

def kplfrm(frmcls):
    r"""kplfrm(SpiceInt frmcls)"""
    return _cspyce0.kplfrm(frmcls)

def latcyl(radius, lon, lat):
    r"""latcyl(SpiceDouble radius, SpiceDouble lon, SpiceDouble lat)"""
    return _cspyce0.latcyl(radius, lon, lat)

def latcyl_vector(in11, in12, in13):
    r"""latcyl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.latcyl_vector(in11, in12, in13)

def latrec(radius, lon, lat):
    r"""latrec(SpiceDouble radius, SpiceDouble lon, SpiceDouble lat)"""
    return _cspyce0.latrec(radius, lon, lat)

def latrec_vector(in11, in12, in13):
    r"""latrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.latrec_vector(in11, in12, in13)

def latsrf(method, target, et, fixref, lonlat):
    r"""latsrf(ConstSpiceChar * method, ConstSpiceChar * target, SpiceDouble et, ConstSpiceChar * fixref, ConstSpiceDouble [][2] lonlat)"""
    return _cspyce0.latsrf(method, target, et, fixref, lonlat)

def latsph(radius, lon, lat):
    r"""latsph(SpiceDouble radius, SpiceDouble lon, SpiceDouble lat)"""
    return _cspyce0.latsph(radius, lon, lat)

def latsph_vector(in11, in12, in13):
    r"""latsph_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.latsph_vector(in11, in12, in13)

def ldpool(CONST_STRING):
    r"""ldpool(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.ldpool(CONST_STRING)

def limbpt(method, target, et, fixref, abcorr, corloc, obsrvr, refvec, rolstp, ncuts, schstp, soltol, maxn):
    r"""limbpt(ConstSpiceChar * method, ConstSpiceChar * target, SpiceDouble et, ConstSpiceChar * fixref, ConstSpiceChar * abcorr, ConstSpiceChar * corloc, ConstSpiceChar * obsrvr, ConstSpiceDouble [3] refvec, SpiceDouble rolstp, SpiceInt ncuts, SpiceDouble schstp, SpiceDouble soltol, SpiceInt maxn)"""
    return _cspyce0.limbpt(method, target, et, fixref, abcorr, corloc, obsrvr, refvec, rolstp, ncuts, schstp, soltol, maxn)

def lspcn(arg1, et, arg3):
    r"""lspcn(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3) -> SpiceDouble"""
    return _cspyce0.lspcn(arg1, et, arg3)

def lspcn_vector(str1, in11, str2):
    r"""lspcn_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2)"""
    return _cspyce0.lspcn_vector(str1, in11, str2)

def ltime(etobs, obs, CONST_STRING, targ):
    r"""ltime(SpiceDouble etobs, SpiceInt obs, ConstSpiceChar * CONST_STRING, SpiceInt targ)"""
    return _cspyce0.ltime(etobs, obs, CONST_STRING, targ)

def ltime_vector(in11, k1, str1, k2):
    r"""ltime_vector(ConstSpiceDouble * in11, SpiceInt k1, ConstSpiceChar * str1, SpiceInt k2)"""
    return _cspyce0.ltime_vector(in11, k1, str1, k2)

def m2eul(r, axis3, axis2, axis1):
    r"""m2eul(ConstSpiceDouble [3][3] r, SpiceInt axis3, SpiceInt axis2, SpiceInt axis1)"""
    return _cspyce0.m2eul(r, axis3, axis2, axis1)

def m2eul_vector(in31, k1, k2, k3):
    r"""m2eul_vector(ConstSpiceDouble * in31, SpiceInt k1, SpiceInt k2, SpiceInt k3)"""
    return _cspyce0.m2eul_vector(in31, k1, k2, k3)

def m2q(r):
    r"""m2q(ConstSpiceDouble [3][3] r)"""
    return _cspyce0.m2q(r)

def m2q_vector(in31):
    r"""m2q_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.m2q_vector(in31)

def mequ(m1):
    r"""mequ(ConstSpiceDouble [3][3] m1)"""
    return _cspyce0.mequ(m1)

def mequ_vector(in31):
    r"""mequ_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.mequ_vector(in31)

def mequg(m1):
    r"""mequg(SpiceDouble * m1)"""
    return _cspyce0.mequg(m1)

def my_mequg_nomalloc(m1, nr, nc, matrix, nr_out, nc_out):
    r"""my_mequg_nomalloc(ConstSpiceDouble * m1, SpiceInt nr, SpiceInt nc, SpiceDouble * matrix, int * nr_out, int * nc_out)"""
    return _cspyce0.my_mequg_nomalloc(m1, nr, nc, matrix, nr_out, nc_out)

def mequg_vector(in31):
    r"""mequg_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.mequg_vector(in31)

def mtxm(m1, m2):
    r"""mtxm(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3][3] m2)"""
    return _cspyce0.mtxm(m1, m2)

def mtxm_vector(in31, in32):
    r"""mtxm_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
    return _cspyce0.mtxm_vector(in31, in32)

def mtxmg(m1, m2):
    r"""mtxmg(SpiceDouble * m1, SpiceDouble * m2)"""
    return _cspyce0.mtxmg(m1, m2)

def my_mtxmg_nomalloc(m1, m2, m3, nr3, nc3):
    r"""my_mtxmg_nomalloc(SpiceDouble * m1, SpiceDouble * m2, SpiceDouble * m3, SpiceInt * nr3, SpiceInt * nc3)"""
    return _cspyce0.my_mtxmg_nomalloc(m1, m2, m3, nr3, nc3)

def mtxmg_vector(in31, in32):
    r"""mtxmg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
    return _cspyce0.mtxmg_vector(in31, in32)

def mtxv(m1, v1):
    r"""mtxv(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3] v1)"""
    return _cspyce0.mtxv(m1, v1)

def mtxv_vector(in31, in21):
    r"""mtxv_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"""
    return _cspyce0.mtxv_vector(in31, in21)

def mtxvg(m1, v2):
    r"""mtxvg(SpiceDouble * m1, SpiceDouble * v2)"""
    return _cspyce0.mtxvg(m1, v2)

def my_mtxvg_nomalloc(m1, nr1, nc1, v2, nr2, v3, nr3):
    r"""my_mtxvg_nomalloc(ConstSpiceDouble * m1, SpiceInt nr1, SpiceInt nc1, ConstSpiceDouble * v2, SpiceInt nr2, SpiceDouble * v3, int * nr3)"""
    return _cspyce0.my_mtxvg_nomalloc(m1, nr1, nc1, v2, nr2, v3, nr3)

def mtxvg_vector(in31, in21):
    r"""mtxvg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"""
    return _cspyce0.mtxvg_vector(in31, in21)

def mxm(m1, m2):
    r"""mxm(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3][3] m2)"""
    return _cspyce0.mxm(m1, m2)

def mxm_vector(in31, in32):
    r"""mxm_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
    return _cspyce0.mxm_vector(in31, in32)

def mxmg(m1, m2):
    r"""mxmg(SpiceDouble * m1, SpiceDouble * m2)"""
    return _cspyce0.mxmg(m1, m2)

def my_mxmg_nomalloc(m1, m2, m3, nr3, nc3):
    r"""my_mxmg_nomalloc(SpiceDouble * m1, SpiceDouble * m2, SpiceDouble * m3, SpiceInt * nr3, SpiceInt * nc3)"""
    return _cspyce0.my_mxmg_nomalloc(m1, m2, m3, nr3, nc3)

def mxmg_vector(in31, in32):
    r"""mxmg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
    return _cspyce0.mxmg_vector(in31, in32)

def mxmt(m1, m2):
    r"""mxmt(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3][3] m2)"""
    return _cspyce0.mxmt(m1, m2)

def mxmt_vector(in31, in32):
    r"""mxmt_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
    return _cspyce0.mxmt_vector(in31, in32)

def mxmtg(m1, m2):
    r"""mxmtg(SpiceDouble * m1, SpiceDouble * m2)"""
    return _cspyce0.mxmtg(m1, m2)

def my_mxmtg_nomalloc(m1, m2, m3, nr3, nc3):
    r"""my_mxmtg_nomalloc(SpiceDouble * m1, SpiceDouble * m2, SpiceDouble * m3, int * nr3, int * nc3)"""
    return _cspyce0.my_mxmtg_nomalloc(m1, m2, m3, nr3, nc3)

def mxmtg_vector(in31, in32):
    r"""mxmtg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
    return _cspyce0.mxmtg_vector(in31, in32)

def mxv(m1, v1):
    r"""mxv(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3] v1)"""
    return _cspyce0.mxv(m1, v1)

def mxv_vector(in31, in21):
    r"""mxv_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"""
    return _cspyce0.mxv_vector(in31, in21)

def mxvg(m1, v2):
    r"""mxvg(SpiceDouble * m1, SpiceDouble * v2)"""
    return _cspyce0.mxvg(m1, v2)

def my_mxvg_nomalloc(m1, v2, v3, nr3):
    r"""my_mxvg_nomalloc(SpiceDouble * m1, SpiceDouble * v2, SpiceDouble * v3, int * nr3)"""
    return _cspyce0.my_mxvg_nomalloc(m1, v2, v3, nr3)

def mxvg_vector(in31, in21):
    r"""mxvg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"""
    return _cspyce0.mxvg_vector(in31, in21)

def namfrm(CONST_STRING):
    r"""namfrm(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.namfrm(CONST_STRING)

def nearpt(positn, a, b, c):
    r"""nearpt(ConstSpiceDouble [3] positn, SpiceDouble a, SpiceDouble b, SpiceDouble c)"""
    return _cspyce0.nearpt(positn, a, b, c)

def nearpt_vector(in21, in11, in12, in13):
    r"""nearpt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.nearpt_vector(in21, in11, in12, in13)

def npedln(a, b, c, linept, linedr):
    r"""npedln(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [3] linept, ConstSpiceDouble [3] linedr)"""
    return _cspyce0.npedln(a, b, c, linept, linedr)

def npedln_vector(in11, in12, in13, in21, in22):
    r"""npedln_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.npedln_vector(in11, in12, in13, in21, in22)

def npelpt(point, ellips):
    r"""npelpt(ConstSpiceDouble [3] point, ConstSpiceDouble [NELLIPSE] ellips)"""
    return _cspyce0.npelpt(point, ellips)

def npelpt_vector(in21, in22):
    r"""npelpt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.npelpt_vector(in21, in22)

def nplnpt(linpt, lindir, point):
    r"""nplnpt(ConstSpiceDouble [3] linpt, ConstSpiceDouble [3] lindir, ConstSpiceDouble [3] point)"""
    return _cspyce0.nplnpt(linpt, lindir, point)

def nplnpt_vector(in21, in22, in23):
    r"""nplnpt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"""
    return _cspyce0.nplnpt_vector(in21, in22, in23)

def nvc2pl(normal, constant):
    r"""nvc2pl(ConstSpiceDouble [3] normal, SpiceDouble constant)"""
    return _cspyce0.nvc2pl(normal, constant)

def nvc2pl_vector(in21, in11):
    r"""nvc2pl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11)"""
    return _cspyce0.nvc2pl_vector(in21, in11)

def nvp2pl(normal, point):
    r"""nvp2pl(ConstSpiceDouble [3] normal, ConstSpiceDouble [3] point)"""
    return _cspyce0.nvp2pl(normal, point)

def nvp2pl_vector(in21, in22):
    r"""nvp2pl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.nvp2pl_vector(in21, in22)

def occult(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, et):
    r"""occult(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceChar * arg8, SpiceDouble et)"""
    return _cspyce0.occult(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, et)

def occult_vector(str1, str2, str3, str4, str5, str6, str7, str8, in11):
    r"""occult_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceChar * str7, ConstSpiceChar * str8, ConstSpiceDouble * in11)"""
    return _cspyce0.occult_vector(str1, str2, str3, str4, str5, str6, str7, str8, in11)

def oscelt(state, et, mu):
    r"""oscelt(ConstSpiceDouble [6] state, SpiceDouble et, SpiceDouble mu)"""
    return _cspyce0.oscelt(state, et, mu)

def oscelt_vector(in21, in11, in12):
    r"""oscelt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
    return _cspyce0.oscelt_vector(in21, in11, in12)

def oscltx(state, et, mu):
    r"""oscltx(ConstSpiceDouble [6] state, SpiceDouble et, SpiceDouble mu)"""
    return _cspyce0.oscltx(state, et, mu)

def oscltx_vector(in21, in11, in12):
    r"""oscltx_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
    return _cspyce0.oscltx_vector(in21, in11, in12)

def pckcov(pck, idcode):
    r"""pckcov(ConstSpiceChar * pck, SpiceInt idcode)"""
    return _cspyce0.pckcov(pck, idcode)

def pckfrm(pck):
    r"""pckfrm(ConstSpiceChar * pck)"""
    return _cspyce0.pckfrm(pck)

def pcpool(CONST_STRING, n):
    r"""pcpool(ConstSpiceChar * CONST_STRING, SpiceInt n)"""
    return _cspyce0.pcpool(CONST_STRING, n)

def pdpool(CONST_STRING, n):
    r"""pdpool(ConstSpiceChar * CONST_STRING, SpiceInt n)"""
    return _cspyce0.pdpool(CONST_STRING, n)

def pgrrec(CONST_STRING, lon, lat, alt, re, f):
    r"""pgrrec(ConstSpiceChar * CONST_STRING, SpiceDouble lon, SpiceDouble lat, SpiceDouble alt, SpiceDouble re, SpiceDouble f)"""
    return _cspyce0.pgrrec(CONST_STRING, lon, lat, alt, re, f)

def pgrrec_vector(str1, in11, in12, in13, in14, in15):
    r"""pgrrec_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"""
    return _cspyce0.pgrrec_vector(str1, in11, in12, in13, in14, in15)

def phaseq(et, arg2, arg3, arg4, arg5):
    r"""phaseq(SpiceDouble et, ConstSpiceChar * arg2, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5) -> SpiceDouble"""
    return _cspyce0.phaseq(et, arg2, arg3, arg4, arg5)

def phaseq_vector(in11, str1, str2, str3, str4):
    r"""phaseq_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4)"""
    return _cspyce0.phaseq_vector(in11, str1, str2, str3, str4)

def pi():
    r"""pi() -> SpiceDouble"""
    return _cspyce0.pi()

def pipool(CONST_STRING, n):
    r"""pipool(ConstSpiceChar * CONST_STRING, SpiceInt n)"""
    return _cspyce0.pipool(CONST_STRING, n)

def pjelpl(elin, plane):
    r"""pjelpl(ConstSpiceDouble [NELLIPSE] elin, ConstSpiceDouble [NPLANE] plane)"""
    return _cspyce0.pjelpl(elin, plane)

def pjelpl_vector(in21, in22):
    r"""pjelpl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.pjelpl_vector(in21, in22)

def pltar(nv, np):
    r"""pltar(SpiceInt nv, SpiceInt np) -> SpiceDouble"""
    return _cspyce0.pltar(nv, np)

def pltexp(iverts, delta):
    r"""pltexp(ConstSpiceDouble [3][3] iverts, SpiceDouble delta)"""
    return _cspyce0.pltexp(iverts, delta)

def pltexp_vector(in31, in11):
    r"""pltexp_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11)"""
    return _cspyce0.pltexp_vector(in31, in11)

def pltnp(point, v1, v2, v3):
    r"""pltnp(ConstSpiceDouble [3] point, ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2, ConstSpiceDouble [3] v3)"""
    return _cspyce0.pltnp(point, v1, v2, v3)

def pltnp_vector(in21, in22, in23, in24):
    r"""pltnp_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23, ConstSpiceDouble * in24)"""
    return _cspyce0.pltnp_vector(in21, in22, in23, in24)

def pltvol(nv, np):
    r"""pltvol(SpiceInt nv, SpiceInt np) -> SpiceDouble"""
    return _cspyce0.pltvol(nv, np)

def pl2nvc(plane):
    r"""pl2nvc(ConstSpiceDouble [NPLANE] plane)"""
    return _cspyce0.pl2nvc(plane)

def pl2nvc_vector(in21):
    r"""pl2nvc_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.pl2nvc_vector(in21)

def pl2nvp(plane):
    r"""pl2nvp(ConstSpiceDouble [NPLANE] plane)"""
    return _cspyce0.pl2nvp(plane)

def pl2nvp_vector(in21):
    r"""pl2nvp_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.pl2nvp_vector(in21)

def pl2psv(plane):
    r"""pl2psv(ConstSpiceDouble [NPLANE] plane)"""
    return _cspyce0.pl2psv(plane)

def pl2psv_vector(in21):
    r"""pl2psv_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.pl2psv_vector(in21)

def prop2b(gm, pvinit, dt):
    r"""prop2b(SpiceDouble gm, ConstSpiceDouble [6] pvinit, SpiceDouble dt)"""
    return _cspyce0.prop2b(gm, pvinit, dt)

def prop2b_vector(in11, in21, in12):
    r"""prop2b_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in12)"""
    return _cspyce0.prop2b_vector(in11, in21, in12)

def psv2pl(point, span1, span2):
    r"""psv2pl(ConstSpiceDouble [3] point, ConstSpiceDouble [3] span1, ConstSpiceDouble [3] span2)"""
    return _cspyce0.psv2pl(point, span1, span2)

def psv2pl_vector(in21, in22, in23):
    r"""psv2pl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"""
    return _cspyce0.psv2pl_vector(in21, in22, in23)

def pxform(arg1, arg2, et):
    r"""pxform(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et)"""
    return _cspyce0.pxform(arg1, arg2, et)

def pxform_vector(str1, str2, in11):
    r"""pxform_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11)"""
    return _cspyce0.pxform_vector(str1, str2, in11)

def pxfrm2(arg1, arg2, etfrom, etto):
    r"""pxfrm2(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble etfrom, SpiceDouble etto)"""
    return _cspyce0.pxfrm2(arg1, arg2, etfrom, etto)

def pxfrm2_vector(str1, str2, in11, in12):
    r"""pxfrm2_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
    return _cspyce0.pxfrm2_vector(str1, str2, in11, in12)

def q2m(q):
    r"""q2m(ConstSpiceDouble [4] q)"""
    return _cspyce0.q2m(q)

def q2m_vector(in21):
    r"""q2m_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.q2m_vector(in21)

def qcktrc():
    r"""qcktrc()"""
    return _cspyce0.qcktrc()

def qdq2av(q, dq):
    r"""qdq2av(ConstSpiceDouble [4] q, ConstSpiceDouble [4] dq)"""
    return _cspyce0.qdq2av(q, dq)

def qdq2av_vector(in21, in22):
    r"""qdq2av_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.qdq2av_vector(in21, in22)

def qxq(q1, q2):
    r"""qxq(ConstSpiceDouble [4] q1, ConstSpiceDouble [4] q2)"""
    return _cspyce0.qxq(q1, q2)

def qxq_vector(in21, in22):
    r"""qxq_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.qxq_vector(in21, in22)

def radrec(range, ra, dec):
    r"""radrec(SpiceDouble range, SpiceDouble ra, SpiceDouble dec)"""
    return _cspyce0.radrec(range, ra, dec)

def radrec_vector(in11, in12, in13):
    r"""radrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.radrec_vector(in11, in12, in13)

def rav2xf(rot, av):
    r"""rav2xf(ConstSpiceDouble [3][3] rot, ConstSpiceDouble [3] av)"""
    return _cspyce0.rav2xf(rot, av)

def rav2xf_vector(in31, in21):
    r"""rav2xf_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"""
    return _cspyce0.rav2xf_vector(in31, in21)

def raxisa(matrix):
    r"""raxisa(ConstSpiceDouble [3][3] matrix)"""
    return _cspyce0.raxisa(matrix)

def raxisa_vector(in31):
    r"""raxisa_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.raxisa_vector(in31)

def reccyl(rectan):
    r"""reccyl(ConstSpiceDouble [3] rectan)"""
    return _cspyce0.reccyl(rectan)

def reccyl_vector(in21):
    r"""reccyl_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.reccyl_vector(in21)

def recgeo(rectan, re, f):
    r"""recgeo(ConstSpiceDouble [3] rectan, SpiceDouble re, SpiceDouble f)"""
    return _cspyce0.recgeo(rectan, re, f)

def recgeo_vector(in21, in11, in12):
    r"""recgeo_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
    return _cspyce0.recgeo_vector(in21, in11, in12)

def reclat(rectan):
    r"""reclat(ConstSpiceDouble [3] rectan)"""
    return _cspyce0.reclat(rectan)

def reclat_vector(in21):
    r"""reclat_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.reclat_vector(in21)

def recpgr(CONST_STRING, rectan, re, f):
    r"""recpgr(ConstSpiceChar * CONST_STRING, SpiceDouble [3] rectan, SpiceDouble re, SpiceDouble f)"""
    return _cspyce0.recpgr(CONST_STRING, rectan, re, f)

def recpgr_vector(str1, in21, in11, in12):
    r"""recpgr_vector(ConstSpiceChar * str1, SpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
    return _cspyce0.recpgr_vector(str1, in21, in11, in12)

def recrad(rectan):
    r"""recrad(ConstSpiceDouble [3] rectan)"""
    return _cspyce0.recrad(rectan)

def recrad_vector(in21):
    r"""recrad_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.recrad_vector(in21)

def recsph(rectan):
    r"""recsph(ConstSpiceDouble [3] rectan)"""
    return _cspyce0.recsph(rectan)

def recsph_vector(in21):
    r"""recsph_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.recsph_vector(in21)

def refchg(frame1, frame2, et):
    r"""refchg(SpiceInt frame1, SpiceInt frame2, SpiceDouble et)"""
    return _cspyce0.refchg(frame1, frame2, et)

def refchg_(frame1, frame2, et, rotate):
    r"""refchg_(SpiceInt * frame1, SpiceInt * frame2, SpiceDouble * et, SpiceDouble * rotate)"""
    return _cspyce0.refchg_(frame1, frame2, et, rotate)

def refchg_vector(k1, k2, in11):
    r"""refchg_vector(SpiceInt k1, SpiceInt k2, ConstSpiceDouble * in11)"""
    return _cspyce0.refchg_vector(k1, k2, in11)

def repmc(arg1, arg2, arg3):
    r"""repmc(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3)"""
    return _cspyce0.repmc(arg1, arg2, arg3)

def repmct(arg1, arg2, value, IN_STRING):
    r"""repmct(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt value, SpiceChar IN_STRING)"""
    return _cspyce0.repmct(arg1, arg2, value, IN_STRING)

def repmd(arg1, arg2, value, sigdig):
    r"""repmd(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble value, SpiceInt sigdig)"""
    return _cspyce0.repmd(arg1, arg2, value, sigdig)

def repmf(arg1, arg2, value, sigdig, format):
    r"""repmf(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble value, SpiceInt sigdig, SpiceChar format)"""
    return _cspyce0.repmf(arg1, arg2, value, sigdig, format)

def repmi(arg1, arg2, value):
    r"""repmi(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt value)"""
    return _cspyce0.repmi(arg1, arg2, value)

def repmot(arg1, arg2, value, IN_STRING):
    r"""repmot(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt value, SpiceChar IN_STRING)"""
    return _cspyce0.repmot(arg1, arg2, value, IN_STRING)

def reset():
    r"""reset()"""
    return _cspyce0.reset()

def rotate(angle, iaxis):
    r"""rotate(SpiceDouble angle, SpiceInt iaxis)"""
    return _cspyce0.rotate(angle, iaxis)

def rotate_vector(in11, k1):
    r"""rotate_vector(ConstSpiceDouble * in11, SpiceInt k1)"""
    return _cspyce0.rotate_vector(in11, k1)

def rotmat(m1, angle, iaxis):
    r"""rotmat(ConstSpiceDouble [3][3] m1, SpiceDouble angle, SpiceInt iaxis)"""
    return _cspyce0.rotmat(m1, angle, iaxis)

def rotmat_vector(in31, in11, k1):
    r"""rotmat_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11, SpiceInt k1)"""
    return _cspyce0.rotmat_vector(in31, in11, k1)

def rotvec(v1, angle, iaxis):
    r"""rotvec(ConstSpiceDouble [3] v1, SpiceDouble angle, SpiceInt iaxis)"""
    return _cspyce0.rotvec(v1, angle, iaxis)

def rotvec_vector(in21, in11, k1):
    r"""rotvec_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, SpiceInt k1)"""
    return _cspyce0.rotvec_vector(in21, in11, k1)

def rpd():
    r"""rpd() -> SpiceDouble"""
    return _cspyce0.rpd()

def rquad(a, b, c):
    r"""rquad(SpiceDouble a, SpiceDouble b, SpiceDouble c)"""
    return _cspyce0.rquad(a, b, c)

def rquad_vector(in11, in12, in13):
    r"""rquad_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.rquad_vector(in11, in12, in13)

def saelgv(vec1, vec2):
    r"""saelgv(ConstSpiceDouble [3] vec1, ConstSpiceDouble [3] vec2)"""
    return _cspyce0.saelgv(vec1, vec2)

def saelgv_vector(in21, in22):
    r"""saelgv_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.saelgv_vector(in21, in22)

def scdecd(sc, sclkdp):
    r"""scdecd(SpiceInt sc, SpiceDouble sclkdp)"""
    return _cspyce0.scdecd(sc, sclkdp)

def sce2c(sc, et):
    r"""sce2c(SpiceInt sc, SpiceDouble et)"""
    return _cspyce0.sce2c(sc, et)

def sce2c_vector(k1, in11):
    r"""sce2c_vector(SpiceInt k1, ConstSpiceDouble * in11)"""
    return _cspyce0.sce2c_vector(k1, in11)

def sce2s(sc, et):
    r"""sce2s(SpiceInt sc, SpiceDouble et)"""
    return _cspyce0.sce2s(sc, et)

def sce2t(sc, et):
    r"""sce2t(SpiceInt sc, SpiceDouble et)"""
    return _cspyce0.sce2t(sc, et)

def sce2t_vector(k1, in11):
    r"""sce2t_vector(SpiceInt k1, ConstSpiceDouble * in11)"""
    return _cspyce0.sce2t_vector(k1, in11)

def scencd(sc, CONST_STRING):
    r"""scencd(SpiceInt sc, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.scencd(sc, CONST_STRING)

def scfmt(sc, ticks):
    r"""scfmt(SpiceInt sc, SpiceDouble ticks)"""
    return _cspyce0.scfmt(sc, ticks)

def scpart(sc):
    r"""scpart(SpiceInt sc)"""
    return _cspyce0.scpart(sc)

def scs2e(sc, CONST_STRING):
    r"""scs2e(SpiceInt sc, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.scs2e(sc, CONST_STRING)

def sct2e(sc, sclkdp):
    r"""sct2e(SpiceInt sc, SpiceDouble sclkdp)"""
    return _cspyce0.sct2e(sc, sclkdp)

def sct2e_vector(k1, in11):
    r"""sct2e_vector(SpiceInt k1, ConstSpiceDouble * in11)"""
    return _cspyce0.sct2e_vector(k1, in11)

def sctiks(sc, CONST_STRING):
    r"""sctiks(SpiceInt sc, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.sctiks(sc, CONST_STRING)

def setmsg(message):
    r"""setmsg(ConstSpiceChar * message)"""
    return _cspyce0.setmsg(message)

def sigerr(CONST_STRING):
    r"""sigerr(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.sigerr(CONST_STRING)

def sincpt(arg1, arg2, et, arg4, arg5, arg6, arg7, dvec):
    r"""sincpt(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceDouble [3] dvec)"""
    return _cspyce0.sincpt(arg1, arg2, et, arg4, arg5, arg6, arg7, dvec)

def sincpt_vector(str1, str2, in11, str3, str4, str5, str6, in21):
    r"""sincpt_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceDouble * in21)"""
    return _cspyce0.sincpt_vector(str1, str2, in11, str3, str4, str5, str6, in21)

def spd():
    r"""spd() -> SpiceDouble"""
    return _cspyce0.spd()

def sphcyl(radius, colat, lon):
    r"""sphcyl(SpiceDouble radius, SpiceDouble colat, SpiceDouble lon)"""
    return _cspyce0.sphcyl(radius, colat, lon)

def sphcyl_vector(in11, in12, in13):
    r"""sphcyl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.sphcyl_vector(in11, in12, in13)

def sphlat(r, colat, lon):
    r"""sphlat(SpiceDouble r, SpiceDouble colat, SpiceDouble lon)"""
    return _cspyce0.sphlat(r, colat, lon)

def sphlat_vector(in11, in12, in13):
    r"""sphlat_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.sphlat_vector(in11, in12, in13)

def sphrec(r, colat, lon):
    r"""sphrec(SpiceDouble r, SpiceDouble colat, SpiceDouble lon)"""
    return _cspyce0.sphrec(r, colat, lon)

def sphrec_vector(in11, in12, in13):
    r"""sphrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.sphrec_vector(in11, in12, in13)

def spkacs(targ, et, arg3, arg4, obs):
    r"""spkacs(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, SpiceInt obs)"""
    return _cspyce0.spkacs(targ, et, arg3, arg4, obs)

def spkacs_vector(k1, in11, str1, str2, k2):
    r"""spkacs_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, SpiceInt k2)"""
    return _cspyce0.spkacs_vector(k1, in11, str1, str2, k2)

def spkapo(targ, et, arg3, sobs, arg5):
    r"""spkapo(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceDouble [6] sobs, ConstSpiceChar * arg5)"""
    return _cspyce0.spkapo(targ, et, arg3, sobs, arg5)

def spkapo_vector(k1, in11, str1, in21, str2):
    r"""spkapo_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceDouble * in21, ConstSpiceChar * str2)"""
    return _cspyce0.spkapo_vector(k1, in11, str1, in21, str2)

def spkapp(targ, et, arg3, sobs, arg5):
    r"""spkapp(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceDouble [6] sobs, ConstSpiceChar * arg5)"""
    return _cspyce0.spkapp(targ, et, arg3, sobs, arg5)

def spkapp_vector(k1, in11, str1, in21, str2):
    r"""spkapp_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceDouble * in21, ConstSpiceChar * str2)"""
    return _cspyce0.spkapp_vector(k1, in11, str1, in21, str2)

def spkaps(targ, et, arg3, arg4, stobs, accobs):
    r"""spkaps(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceDouble [6] stobs, ConstSpiceDouble [3] accobs)"""
    return _cspyce0.spkaps(targ, et, arg3, arg4, stobs, accobs)

def spkaps_vector(k1, in11, str1, str2, in21, in22):
    r"""spkaps_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.spkaps_vector(k1, in11, str1, str2, in21, in22)

def spkcov(spk, idcode):
    r"""spkcov(ConstSpiceChar * spk, SpiceInt idcode)"""
    return _cspyce0.spkcov(spk, idcode)

def spkez(targ, et, arg3, arg4, obs):
    r"""spkez(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, SpiceInt obs)"""
    return _cspyce0.spkez(targ, et, arg3, arg4, obs)

def spkez_vector(k1, in11, str1, str2, k2):
    r"""spkez_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, SpiceInt k2)"""
    return _cspyce0.spkez_vector(k1, in11, str1, str2, k2)

def spkezp(targ, et, arg3, arg4, obs):
    r"""spkezp(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, SpiceInt obs)"""
    return _cspyce0.spkezp(targ, et, arg3, arg4, obs)

def spkezp_vector(k1, in11, str1, str2, k2):
    r"""spkezp_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, SpiceInt k2)"""
    return _cspyce0.spkezp_vector(k1, in11, str1, str2, k2)

def spkezr(arg1, et, arg3, arg4, arg5):
    r"""spkezr(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5)"""
    return _cspyce0.spkezr(arg1, et, arg3, arg4, arg5)

def spkezr_vector(str1, in11, str2, str3, str4):
    r"""spkezr_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4)"""
    return _cspyce0.spkezr_vector(str1, in11, str2, str3, str4)

def spkgeo(targ, et, CONST_STRING, obs):
    r"""spkgeo(SpiceInt targ, SpiceDouble et, ConstSpiceChar * CONST_STRING, SpiceInt obs)"""
    return _cspyce0.spkgeo(targ, et, CONST_STRING, obs)

def spkgeo_vector(k1, in11, str1, k2):
    r"""spkgeo_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, SpiceInt k2)"""
    return _cspyce0.spkgeo_vector(k1, in11, str1, k2)

def spkgps(targ, et, CONST_STRING, obs):
    r"""spkgps(SpiceInt targ, SpiceDouble et, ConstSpiceChar * CONST_STRING, SpiceInt obs)"""
    return _cspyce0.spkgps(targ, et, CONST_STRING, obs)

def spkgps_vector(k1, in11, str1, k2):
    r"""spkgps_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, SpiceInt k2)"""
    return _cspyce0.spkgps_vector(k1, in11, str1, k2)

def spkltc(targ, et, arg3, arg4, stobs):
    r"""spkltc(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceDouble [6] stobs)"""
    return _cspyce0.spkltc(targ, et, arg3, arg4, stobs)

def spkltc_vector(k1, in11, str1, str2, in21):
    r"""spkltc_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in21)"""
    return _cspyce0.spkltc_vector(k1, in11, str1, str2, in21)

def spkobj(spk):
    r"""spkobj(ConstSpiceChar * spk)"""
    return _cspyce0.spkobj(spk)

def spkpos(arg1, et, arg3, arg4, arg5):
    r"""spkpos(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5)"""
    return _cspyce0.spkpos(arg1, et, arg3, arg4, arg5)

def spkpos_vector(str1, in11, str2, str3, str4):
    r"""spkpos_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4)"""
    return _cspyce0.spkpos_vector(str1, in11, str2, str3, str4)

def spkssb(targ, et, CONST_STRING):
    r"""spkssb(SpiceInt targ, SpiceDouble et, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.spkssb(targ, et, CONST_STRING)

def spkssb_vector(k1, in11, str1):
    r"""spkssb_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1)"""
    return _cspyce0.spkssb_vector(k1, in11, str1)

def srfc2s(code, bodyid):
    r"""srfc2s(SpiceInt code, SpiceInt bodyid)"""
    return _cspyce0.srfc2s(code, bodyid)

def srfcss(code, CONST_STRING):
    r"""srfcss(SpiceInt code, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.srfcss(code, CONST_STRING)

def srfnrm(method, target, et, fixref, npts):
    r"""srfnrm(ConstSpiceChar * method, ConstSpiceChar * target, SpiceDouble et, ConstSpiceChar * fixref, SpiceInt npts)"""
    return _cspyce0.srfnrm(method, target, et, fixref, npts)

def srfrec(body, lon, lat):
    r"""srfrec(SpiceInt body, SpiceDouble lon, SpiceDouble lat)"""
    return _cspyce0.srfrec(body, lon, lat)

def srfrec_vector(k1, in11, in12):
    r"""srfrec_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
    return _cspyce0.srfrec_vector(k1, in11, in12)

def srfs2c(arg1, arg2):
    r"""srfs2c(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"""
    return _cspyce0.srfs2c(arg1, arg2)

def srfscc(CONST_STRING, bodyid):
    r"""srfscc(ConstSpiceChar * CONST_STRING, SpiceInt bodyid)"""
    return _cspyce0.srfscc(CONST_STRING, bodyid)

def srfxpt(arg1, arg2, et, arg4, arg5, arg6, dvec):
    r"""srfxpt(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceDouble [3] dvec)"""
    return _cspyce0.srfxpt(arg1, arg2, et, arg4, arg5, arg6, dvec)

def srfxpt_vector(str1, str2, in11, str3, str4, str5, in21):
    r"""srfxpt_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceDouble * in21)"""
    return _cspyce0.srfxpt_vector(str1, str2, in11, str3, str4, str5, in21)

def stcf01(catnam, westra, eastra, sthdec, nthdec):
    r"""stcf01(ConstSpiceChar * catnam, SpiceDouble westra, SpiceDouble eastra, SpiceDouble sthdec, SpiceDouble nthdec)"""
    return _cspyce0.stcf01(catnam, westra, eastra, sthdec, nthdec)

def stcg01(index):
    r"""stcg01(SpiceInt index)"""
    return _cspyce0.stcg01(index)

def stcl01(catfnm):
    r"""stcl01(ConstSpiceChar * catfnm)"""
    return _cspyce0.stcl01(catfnm)

def stelab(pobj, vobs):
    r"""stelab(ConstSpiceDouble [3] pobj, ConstSpiceDouble [3] vobs)"""
    return _cspyce0.stelab(pobj, vobs)

def stelab_vector(in21, in22):
    r"""stelab_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.stelab_vector(in21, in22)

def stlabx(pobj, vobs):
    r"""stlabx(ConstSpiceDouble [3] pobj, ConstSpiceDouble [3] vobs)"""
    return _cspyce0.stlabx(pobj, vobs)

def stlabx_vector(in21, in22):
    r"""stlabx_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.stlabx_vector(in21, in22)

def stpool(item, nth, contin):
    r"""stpool(ConstSpiceChar * item, SpiceInt nth, ConstSpiceChar * contin)"""
    return _cspyce0.stpool(item, nth, contin)

def str2et(CONST_STRING):
    r"""str2et(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.str2et(CONST_STRING)

def subpnt(arg1, arg2, et, arg4, arg5, arg6):
    r"""subpnt(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6)"""
    return _cspyce0.subpnt(arg1, arg2, et, arg4, arg5, arg6)

def subpnt_vector(str1, str2, in11, str3, str4, str5):
    r"""subpnt_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5)"""
    return _cspyce0.subpnt_vector(str1, str2, in11, str3, str4, str5)

def subpt(arg1, arg2, et, arg4, arg5):
    r"""subpt(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5)"""
    return _cspyce0.subpt(arg1, arg2, et, arg4, arg5)

def subpt_vector(str1, str2, in11, str3, str4):
    r"""subpt_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4)"""
    return _cspyce0.subpt_vector(str1, str2, in11, str3, str4)

def subslr(arg1, arg2, et, arg4, arg5, arg6):
    r"""subslr(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6)"""
    return _cspyce0.subslr(arg1, arg2, et, arg4, arg5, arg6)

def subslr_vector(str1, str2, in11, str3, str4, str5):
    r"""subslr_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5)"""
    return _cspyce0.subslr_vector(str1, str2, in11, str3, str4, str5)

def subsol(arg1, arg2, et, arg4, arg5):
    r"""subsol(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5)"""
    return _cspyce0.subsol(arg1, arg2, et, arg4, arg5)

def subsol_vector(str1, str2, in11, str3, str4):
    r"""subsol_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4)"""
    return _cspyce0.subsol_vector(str1, str2, in11, str3, str4)

def surfnm(a, b, c, point):
    r"""surfnm(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [3] point)"""
    return _cspyce0.surfnm(a, b, c, point)

def surfpt(positn, u, a, b, c):
    r"""surfpt(ConstSpiceDouble [3] positn, ConstSpiceDouble [3] u, SpiceDouble a, SpiceDouble b, SpiceDouble c)"""
    return _cspyce0.surfpt(positn, u, a, b, c)

def surfpt_vector(in21, in22, in11, in12, in13):
    r"""surfpt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.surfpt_vector(in21, in22, in11, in12, in13)

def surfpv(stvrtx, stdir, a, b, c):
    r"""surfpv(ConstSpiceDouble [6] stvrtx, ConstSpiceDouble [6] stdir, SpiceDouble a, SpiceDouble b, SpiceDouble c)"""
    return _cspyce0.surfpv(stvrtx, stdir, a, b, c)

def surfpv_vector(in21, in22, in11, in12, in13):
    r"""surfpv_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.surfpv_vector(in21, in22, in11, in12, in13)

def sxform(arg1, arg2, et):
    r"""sxform(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et)"""
    return _cspyce0.sxform(arg1, arg2, et)

def sxform_vector(str1, str2, in11):
    r"""sxform_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11)"""
    return _cspyce0.sxform_vector(str1, str2, in11)

def termpt(method, ilusrc, target, et, fixref, abcorr, corloc, obsrvr, refvec, rolstp, ncuts, schstp, soltol, maxn):
    r"""termpt(ConstSpiceChar * method, ConstSpiceChar * ilusrc, ConstSpiceChar * target, SpiceDouble et, ConstSpiceChar * fixref, ConstSpiceChar * abcorr, ConstSpiceChar * corloc, ConstSpiceChar * obsrvr, ConstSpiceDouble [3] refvec, SpiceDouble rolstp, SpiceInt ncuts, SpiceDouble schstp, SpiceDouble soltol, SpiceInt maxn)"""
    return _cspyce0.termpt(method, ilusrc, target, et, fixref, abcorr, corloc, obsrvr, refvec, rolstp, ncuts, schstp, soltol, maxn)

def timdef(arg1, arg2, lenout):
    r"""timdef(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt lenout)"""
    return _cspyce0.timdef(arg1, arg2, lenout)

def timout(et, CONST_STRING):
    r"""timout(SpiceDouble et, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.timout(et, CONST_STRING)

def tipbod(CONST_STRING, body, et):
    r"""tipbod(ConstSpiceChar * CONST_STRING, SpiceInt body, SpiceDouble et)"""
    return _cspyce0.tipbod(CONST_STRING, body, et)

def tipbod_vector(str1, k1, in11):
    r"""tipbod_vector(ConstSpiceChar * str1, SpiceInt k1, ConstSpiceDouble * in11)"""
    return _cspyce0.tipbod_vector(str1, k1, in11)

def tisbod(CONST_STRING, body, et):
    r"""tisbod(ConstSpiceChar * CONST_STRING, SpiceInt body, SpiceDouble et)"""
    return _cspyce0.tisbod(CONST_STRING, body, et)

def tisbod_vector(str1, k1, in11):
    r"""tisbod_vector(ConstSpiceChar * str1, SpiceInt k1, ConstSpiceDouble * in11)"""
    return _cspyce0.tisbod_vector(str1, k1, in11)

def tkvrsn(CONST_STRING):
    r"""tkvrsn(ConstSpiceChar * CONST_STRING) -> SpiceChar *"""
    return _cspyce0.tkvrsn(CONST_STRING)

def tparse(string):
    r"""tparse(ConstSpiceChar * string)"""
    return _cspyce0.tparse(string)

def tpictr(sample):
    r"""tpictr(ConstSpiceChar * sample)"""
    return _cspyce0.tpictr(sample)

def trace(matrix):
    r"""trace(ConstSpiceDouble [3][3] matrix) -> SpiceDouble"""
    return _cspyce0.trace(matrix)

def trace_vector(in31):
    r"""trace_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.trace_vector(in31)

def trcoff():
    r"""trcoff()"""
    return _cspyce0.trcoff()

def trcdep():
    r"""trcdep()"""
    return _cspyce0.trcdep()

def trcnam(index):
    r"""trcnam(SpiceInt index)"""
    return _cspyce0.trcnam(index)

def tsetyr(year):
    r"""tsetyr(SpiceInt year)"""
    return _cspyce0.tsetyr(year)

def twopi():
    r"""twopi() -> SpiceDouble"""
    return _cspyce0.twopi()

def twovec(axdef, indexa, plndef, indexp):
    r"""twovec(ConstSpiceDouble [3] axdef, SpiceInt indexa, ConstSpiceDouble [3] plndef, SpiceInt indexp)"""
    return _cspyce0.twovec(axdef, indexa, plndef, indexp)

def twovec_vector(in21, k1, in22, k2):
    r"""twovec_vector(ConstSpiceDouble * in21, SpiceInt k1, ConstSpiceDouble * in22, SpiceInt k2)"""
    return _cspyce0.twovec_vector(in21, k1, in22, k2)

def tyear():
    r"""tyear() -> SpiceDouble"""
    return _cspyce0.tyear()

def ucrss(v1, v2):
    r"""ucrss(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"""
    return _cspyce0.ucrss(v1, v2)

def ucrss_vector(in21, in22):
    r"""ucrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.ucrss_vector(in21, in22)

def unitim(epoch, arg2, arg3):
    r"""unitim(SpiceDouble epoch, ConstSpiceChar * arg2, ConstSpiceChar * arg3) -> SpiceDouble"""
    return _cspyce0.unitim(epoch, arg2, arg3)

def unitim_vector(in11, str1, str2):
    r"""unitim_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2)"""
    return _cspyce0.unitim_vector(in11, str1, str2)

def unload(CONST_STRING):
    r"""unload(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.unload(CONST_STRING)

def unorm(v1):
    r"""unorm(ConstSpiceDouble [3] v1)"""
    return _cspyce0.unorm(v1)

def unorm_vector(in21):
    r"""unorm_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.unorm_vector(in21)

def unormg(v1):
    r"""unormg(ConstSpiceDouble * v1)"""
    return _cspyce0.unormg(v1)

def my_unormg_nomalloc(v1, vector, nd2):
    r"""my_unormg_nomalloc(ConstSpiceDouble * v1, SpiceDouble * vector, int * nd2)"""
    return _cspyce0.my_unormg_nomalloc(v1, vector, nd2)

def unormg_vector(in21):
    r"""unormg_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.unormg_vector(in21)

def utc2et(CONST_STRING):
    r"""utc2et(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.utc2et(CONST_STRING)

def vadd(v1, v2):
    r"""vadd(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"""
    return _cspyce0.vadd(v1, v2)

def vadd_vector(in21, in22):
    r"""vadd_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vadd_vector(in21, in22)

def vaddg(v1, v2):
    r"""vaddg(ConstSpiceDouble * v1, ConstSpiceDouble * v2)"""
    return _cspyce0.vaddg(v1, v2)

def my_vaddg_nomalloc(v1, v2, v3, nd3):
    r"""my_vaddg_nomalloc(ConstSpiceDouble * v1, ConstSpiceDouble * v2, SpiceDouble * v3, int * nd3)"""
    return _cspyce0.my_vaddg_nomalloc(v1, v2, v3, nd3)

def vaddg_vector(in21, in22):
    r"""vaddg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vaddg_vector(in21, in22)

def vcrss(v1, v2):
    r"""vcrss(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"""
    return _cspyce0.vcrss(v1, v2)

def vcrss_vector(in21, in22):
    r"""vcrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vcrss_vector(in21, in22)

def vdist(v1, v2):
    r"""vdist(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"""
    return _cspyce0.vdist(v1, v2)

def vdist_vector(in21, in22):
    r"""vdist_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vdist_vector(in21, in22)

def vdistg(v1, v2):
    r"""vdistg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"""
    return _cspyce0.vdistg(v1, v2)

def vdistg_vector(in21, in22):
    r"""vdistg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vdistg_vector(in21, in22)

def vdot(v1, v2):
    r"""vdot(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"""
    return _cspyce0.vdot(v1, v2)

def vdot_vector(in21, in22):
    r"""vdot_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vdot_vector(in21, in22)

def vdotg(v1, v2):
    r"""vdotg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"""
    return _cspyce0.vdotg(v1, v2)

def vdotg_vector(in21, in22):
    r"""vdotg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vdotg_vector(in21, in22)

def vequ(v1):
    r"""vequ(ConstSpiceDouble [3] v1)"""
    return _cspyce0.vequ(v1)

def vequ_vector(in21):
    r"""vequ_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.vequ_vector(in21)

def vequg(v1):
    r"""vequg(ConstSpiceDouble * v1)"""
    return _cspyce0.vequg(v1)

def my_vequg_nomalloc(v1, v2, nd2):
    r"""my_vequg_nomalloc(ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"""
    return _cspyce0.my_vequg_nomalloc(v1, v2, nd2)

def vequg_vector(in21):
    r"""vequg_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.vequg_vector(in21)

def vhat(v1):
    r"""vhat(ConstSpiceDouble [3] v1)"""
    return _cspyce0.vhat(v1)

def vhat_vector(in21):
    r"""vhat_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.vhat_vector(in21)

def vhatg(v1):
    r"""vhatg(ConstSpiceDouble * v1)"""
    return _cspyce0.vhatg(v1)

def my_vhatg_nomalloc(v1, v2, nd2):
    r"""my_vhatg_nomalloc(ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"""
    return _cspyce0.my_vhatg_nomalloc(v1, v2, nd2)

def vhatg_vector(in21):
    r"""vhatg_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.vhatg_vector(in21)

def vlcom3(a, v1, b, v2, c, v3):
    r"""vlcom3(SpiceDouble a, ConstSpiceDouble [3] v1, SpiceDouble b, ConstSpiceDouble [3] v2, SpiceDouble c, ConstSpiceDouble [3] v3)"""
    return _cspyce0.vlcom3(a, v1, b, v2, c, v3)

def vlcom3_vector(in11, in21, in12, in22, in13, in23):
    r"""vlcom3_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in12, ConstSpiceDouble * in22, ConstSpiceDouble * in13, ConstSpiceDouble * in23)"""
    return _cspyce0.vlcom3_vector(in11, in21, in12, in22, in13, in23)

def vlcom(a, v1, b, v2):
    r"""vlcom(SpiceDouble a, ConstSpiceDouble [3] v1, SpiceDouble b, ConstSpiceDouble [3] v2)"""
    return _cspyce0.vlcom(a, v1, b, v2)

def vlcom_vector(in11, in21, in12, in22):
    r"""vlcom_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in12, ConstSpiceDouble * in22)"""
    return _cspyce0.vlcom_vector(in11, in21, in12, in22)

def vlcomg(a, v1, b, v2):
    r"""vlcomg(SpiceDouble a, ConstSpiceDouble * v1, SpiceDouble b, ConstSpiceDouble * v2)"""
    return _cspyce0.vlcomg(a, v1, b, v2)

def my_vlcomg_nomalloc(a, v1, b, v2, v3, nd3):
    r"""my_vlcomg_nomalloc(SpiceDouble a, ConstSpiceDouble * v1, SpiceDouble b, ConstSpiceDouble * v2, SpiceDouble * v3, int * nd3)"""
    return _cspyce0.my_vlcomg_nomalloc(a, v1, b, v2, v3, nd3)

def vlcomg_vector(in11, in21, in12, in22):
    r"""vlcomg_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in12, ConstSpiceDouble * in22)"""
    return _cspyce0.vlcomg_vector(in11, in21, in12, in22)

def vminug(v1):
    r"""vminug(ConstSpiceDouble * v1)"""
    return _cspyce0.vminug(v1)

def my_vminug_nomalloc(v1, v2, nd2):
    r"""my_vminug_nomalloc(ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"""
    return _cspyce0.my_vminug_nomalloc(v1, v2, nd2)

def vminug_vector(in21):
    r"""vminug_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.vminug_vector(in21)

def vminus(v1):
    r"""vminus(ConstSpiceDouble [3] v1)"""
    return _cspyce0.vminus(v1)

def vminus_vector(in21):
    r"""vminus_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.vminus_vector(in21)

def vnorm(v1):
    r"""vnorm(ConstSpiceDouble [3] v1) -> SpiceDouble"""
    return _cspyce0.vnorm(v1)

def vnorm_vector(in21):
    r"""vnorm_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.vnorm_vector(in21)

def vnormg(v1):
    r"""vnormg(ConstSpiceDouble * v1) -> SpiceDouble"""
    return _cspyce0.vnormg(v1)

def vnormg_vector(in21):
    r"""vnormg_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.vnormg_vector(in21)

def vpack(x, y, z):
    r"""vpack(SpiceDouble x, SpiceDouble y, SpiceDouble z)"""
    return _cspyce0.vpack(x, y, z)

def vpack_vector(in11, in12, in13):
    r"""vpack_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.vpack_vector(in11, in12, in13)

def vperp(a, b):
    r"""vperp(ConstSpiceDouble [3] a, ConstSpiceDouble [3] b)"""
    return _cspyce0.vperp(a, b)

def vperp_vector(in21, in22):
    r"""vperp_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vperp_vector(in21, in22)

def vprjp(v1, plane):
    r"""vprjp(ConstSpiceDouble [3] v1, ConstSpiceDouble [NPLANE] plane)"""
    return _cspyce0.vprjp(v1, plane)

def vprjp_vector(in21, in22):
    r"""vprjp_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vprjp_vector(in21, in22)

def vprjpi(v1, projpl, invpl):
    r"""vprjpi(ConstSpiceDouble [3] v1, ConstSpiceDouble [NPLANE] projpl, ConstSpiceDouble [NPLANE] invpl)"""
    return _cspyce0.vprjpi(v1, projpl, invpl)

def vprjpi_vector(in21, in22, in23):
    r"""vprjpi_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"""
    return _cspyce0.vprjpi_vector(in21, in22, in23)

def vproj(a, b):
    r"""vproj(ConstSpiceDouble [3] a, ConstSpiceDouble [3] b)"""
    return _cspyce0.vproj(a, b)

def vproj_vector(in21, in22):
    r"""vproj_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vproj_vector(in21, in22)

def vrel(v1, v2):
    r"""vrel(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"""
    return _cspyce0.vrel(v1, v2)

def vrel_vector(in21, in22):
    r"""vrel_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vrel_vector(in21, in22)

def vrelg(v1, v2):
    r"""vrelg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"""
    return _cspyce0.vrelg(v1, v2)

def vrelg_vector(in21, in22):
    r"""vrelg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vrelg_vector(in21, in22)

def vrotv(v, axis, theta):
    r"""vrotv(ConstSpiceDouble [3] v, ConstSpiceDouble [3] axis, SpiceDouble theta)"""
    return _cspyce0.vrotv(v, axis, theta)

def vrotv_vector(in21, in22, in11):
    r"""vrotv_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"""
    return _cspyce0.vrotv_vector(in21, in22, in11)

def vscl(s, v1):
    r"""vscl(SpiceDouble s, ConstSpiceDouble [3] v1)"""
    return _cspyce0.vscl(s, v1)

def vscl_vector(in11, in21):
    r"""vscl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21)"""
    return _cspyce0.vscl_vector(in11, in21)

def vsclg(s, v1):
    r"""vsclg(SpiceDouble s, ConstSpiceDouble * v1)"""
    return _cspyce0.vsclg(s, v1)

def my_vsclg_nomalloc(s, v1, v2, nd2):
    r"""my_vsclg_nomalloc(SpiceDouble s, ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"""
    return _cspyce0.my_vsclg_nomalloc(s, v1, v2, nd2)

def vsclg_vector(in11, in21):
    r"""vsclg_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21)"""
    return _cspyce0.vsclg_vector(in11, in21)

def vsep(v1, v2):
    r"""vsep(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"""
    return _cspyce0.vsep(v1, v2)

def vsep_vector(in21, in22):
    r"""vsep_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vsep_vector(in21, in22)

def vsepg(v1, v2):
    r"""vsepg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"""
    return _cspyce0.vsepg(v1, v2)

def vsepg_vector(in21, in22):
    r"""vsepg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vsepg_vector(in21, in22)

def vsub(v1, v2):
    r"""vsub(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"""
    return _cspyce0.vsub(v1, v2)

def vsub_vector(in21, in22):
    r"""vsub_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vsub_vector(in21, in22)

def vsubg(v1, v2):
    r"""vsubg(ConstSpiceDouble * v1, ConstSpiceDouble * v2)"""
    return _cspyce0.vsubg(v1, v2)

def my_vsubg_nomalloc(v1, v2, v3, nd3):
    r"""my_vsubg_nomalloc(ConstSpiceDouble * v1, ConstSpiceDouble * v2, SpiceDouble * v3, int * nd3)"""
    return _cspyce0.my_vsubg_nomalloc(v1, v2, v3, nd3)

def vsubg_vector(in21, in22):
    r"""vsubg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vsubg_vector(in21, in22)

def vtmv(v1, matrix, v2):
    r"""vtmv(ConstSpiceDouble [3] v1, ConstSpiceDouble [3][3] matrix, ConstSpiceDouble [3] v2) -> SpiceDouble"""
    return _cspyce0.vtmv(v1, matrix, v2)

def vtmv_vector(in21, in31, in22):
    r"""vtmv_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in31, ConstSpiceDouble * in22)"""
    return _cspyce0.vtmv_vector(in21, in31, in22)

def vtmvg(v1, matrix, v2):
    r"""vtmvg(SpiceDouble * v1, SpiceDouble * matrix, SpiceDouble * v2) -> SpiceDouble"""
    return _cspyce0.vtmvg(v1, matrix, v2)

def vtmvg_vector(in21, in31, in22):
    r"""vtmvg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in31, ConstSpiceDouble * in22)"""
    return _cspyce0.vtmvg_vector(in21, in31, in22)

def vupack(v):
    r"""vupack(ConstSpiceDouble [3] v)"""
    return _cspyce0.vupack(v)

def vupack_vector(in21):
    r"""vupack_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.vupack_vector(in21)

def vzero(v):
    r"""vzero(ConstSpiceDouble [3] v) -> SpiceBoolean"""
    return _cspyce0.vzero(v)

def vzero_vector(in21):
    r"""vzero_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.vzero_vector(in21)

def vzerog(v):
    r"""vzerog(ConstSpiceDouble * v) -> SpiceBoolean"""
    return _cspyce0.vzerog(v)

def vzerog_vector(in21):
    r"""vzerog_vector(ConstSpiceDouble * in21)"""
    return _cspyce0.vzerog_vector(in21)

def xf2eul(xform, axisa, axisb, axisc):
    r"""xf2eul(ConstSpiceDouble [6][6] xform, SpiceInt axisa, SpiceInt axisb, SpiceInt axisc)"""
    return _cspyce0.xf2eul(xform, axisa, axisb, axisc)

def xf2eul_vector(in31, in11, in12, in13):
    r"""xf2eul_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.xf2eul_vector(in31, in11, in12, in13)

def xf2rav(xform):
    r"""xf2rav(ConstSpiceDouble [6][6] xform)"""
    return _cspyce0.xf2rav(xform)

def xf2rav_vector(in31):
    r"""xf2rav_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.xf2rav_vector(in31)

def xfmsta(state1, arg2, arg3, arg4):
    r"""xfmsta(ConstSpiceDouble [6] state1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, ConstSpiceChar * arg4)"""
    return _cspyce0.xfmsta(state1, arg2, arg3, arg4)

def xfmsta_vector(in21, str1, str2, str3):
    r"""xfmsta_vector(ConstSpiceDouble * in21, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3)"""
    return _cspyce0.xfmsta_vector(in21, str1, str2, str3)

def xpose6(m1):
    r"""xpose6(ConstSpiceDouble [6][6] m1)"""
    return _cspyce0.xpose6(m1)

def xpose6_vector(in31):
    r"""xpose6_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.xpose6_vector(in31)

def xpose(m1):
    r"""xpose(ConstSpiceDouble [3][3] m1)"""
    return _cspyce0.xpose(m1)

def xpose_vector(in31):
    r"""xpose_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.xpose_vector(in31)

def xposeg(matrix):
    r"""xposeg(ConstSpiceDouble * matrix)"""
    return _cspyce0.xposeg(matrix)

def my_xposeg_nomalloc(matrix, xposem, nrow1, nc1):
    r"""my_xposeg_nomalloc(ConstSpiceDouble * matrix, SpiceDouble * xposem, int * nrow1, int * nc1)"""
    return _cspyce0.my_xposeg_nomalloc(matrix, xposem, nrow1, nc1)

def xposeg_vector(in31):
    r"""xposeg_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.xposeg_vector(in31)

def azlcpo(arg1, arg2, et, arg4, azccw, elplsz, obspos, arg8, arg9):
    r"""azlcpo(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, SpiceBoolean azccw, SpiceBoolean elplsz, ConstSpiceDouble [3] obspos, ConstSpiceChar * arg8, ConstSpiceChar * arg9)"""
    return _cspyce0.azlcpo(arg1, arg2, et, arg4, azccw, elplsz, obspos, arg8, arg9)

def azlcpo_vector(str1, str2, in11, str3, b1, b2, in21, str4, str5):
    r"""azlcpo_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, SpiceBoolean b1, SpiceBoolean b2, ConstSpiceDouble * in21, ConstSpiceChar * str4, ConstSpiceChar * str5)"""
    return _cspyce0.azlcpo_vector(str1, str2, in11, str3, b1, b2, in21, str4, str5)

def azlrec(range, az, el, azccw, elplsz):
    r"""azlrec(SpiceDouble range, SpiceDouble az, SpiceDouble el, SpiceBoolean azccw, SpiceBoolean elplsz)"""
    return _cspyce0.azlrec(range, az, el, azccw, elplsz)

def azlrec_vector(in11, in12, in13, b1, b2):
    r"""azlrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, SpiceBoolean b1, SpiceBoolean b2)"""
    return _cspyce0.azlrec_vector(in11, in12, in13, b1, b2)

def badkpv(arg1, arg2, arg3, size, divby, IN_STRING):
    r"""badkpv(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceInt size, SpiceInt divby, SpiceChar IN_STRING)"""
    return _cspyce0.badkpv(arg1, arg2, arg3, size, divby, IN_STRING)

def brcktd(number, end1, end2):
    r"""brcktd(SpiceDouble number, SpiceDouble end1, SpiceDouble end2) -> SpiceDouble"""
    return _cspyce0.brcktd(number, end1, end2)

def brcktd_vector(in11, in12, in13):
    r"""brcktd_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.brcktd_vector(in11, in12, in13)

def brckti(number, end1, end2):
    r"""brckti(SpiceInt number, SpiceInt end1, SpiceInt end2) -> SpiceInt"""
    return _cspyce0.brckti(number, end1, end2)

def bschoc(CONST_STRING, ndim, order):
    r"""bschoc(ConstSpiceChar * CONST_STRING, SpiceInt ndim, ConstSpiceInt * order) -> SpiceInt"""
    return _cspyce0.bschoc(CONST_STRING, ndim, order)

def bschoi(value, ndim, order):
    r"""bschoi(SpiceInt value, SpiceInt ndim, ConstSpiceInt * order) -> SpiceInt"""
    return _cspyce0.bschoi(value, ndim, order)

def bsrchc(CONST_STRING, ndim):
    r"""bsrchc(ConstSpiceChar * CONST_STRING, SpiceInt ndim) -> SpiceInt"""
    return _cspyce0.bsrchc(CONST_STRING, ndim)

def bsrchd(value, ndim):
    r"""bsrchd(SpiceDouble value, SpiceInt ndim) -> SpiceInt"""
    return _cspyce0.bsrchd(value, ndim)

def my_bsrchd_vector(value, array, ndim):
    r"""my_bsrchd_vector(SpiceDouble value, ConstSpiceDouble * array, SpiceInt ndim) -> SpiceInt"""
    return _cspyce0.my_bsrchd_vector(value, array, ndim)

def bsrchd_vector(in11, in21):
    r"""bsrchd_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21)"""
    return _cspyce0.bsrchd_vector(in11, in21)

def bsrchi(value, ndim):
    r"""bsrchi(SpiceInt value, SpiceInt ndim) -> SpiceInt"""
    return _cspyce0.bsrchi(value, ndim)

def chbder(cp, x2s, x, nderiv):
    r"""chbder(ConstSpiceDouble * cp, SpiceDouble [2] x2s, SpiceDouble x, SpiceInt nderiv)"""
    return _cspyce0.chbder(cp, x2s, x, nderiv)

def chbder_vector(in21, x2s, in12, nderiv):
    r"""chbder_vector(ConstSpiceDouble * in21, SpiceDouble [2] x2s, ConstSpiceDouble * in12, SpiceInt nderiv)"""
    return _cspyce0.chbder_vector(in21, x2s, in12, nderiv)

def chbigr(cp, x2s, x):
    r"""chbigr(ConstSpiceDouble * cp, ConstSpiceDouble [2] x2s, SpiceDouble x)"""
    return _cspyce0.chbigr(cp, x2s, x)

def chbigr_vector(in21, in22, in11):
    r"""chbigr_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"""
    return _cspyce0.chbigr_vector(in21, in22, in11)

def chbint(cp, x2s, x):
    r"""chbint(ConstSpiceDouble * cp, ConstSpiceDouble [2] x2s, SpiceDouble x)"""
    return _cspyce0.chbint(cp, x2s, x)

def chbint_vector(in21, in22, in11):
    r"""chbint_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"""
    return _cspyce0.chbint_vector(in21, in22, in11)

def chbval(cp, x2s, x):
    r"""chbval(ConstSpiceDouble * cp, ConstSpiceDouble [2] x2s, SpiceDouble x)"""
    return _cspyce0.chbval(cp, x2s, x)

def chbval_vector(in21, in22, in11):
    r"""chbval_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"""
    return _cspyce0.chbval_vector(in21, in22, in11)

def ckcls(handle):
    r"""ckcls(SpiceInt handle)"""
    return _cspyce0.ckcls(handle)

def ckfrot(inst, et):
    r"""ckfrot(SpiceInt inst, SpiceDouble et)"""
    return _cspyce0.ckfrot(inst, et)

def ckfrot_vector(k1, in11, in31):
    r"""ckfrot_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in31)"""
    return _cspyce0.ckfrot_vector(k1, in11, in31)

def ckfxfm(inst, et):
    r"""ckfxfm(SpiceInt inst, SpiceDouble et)"""
    return _cspyce0.ckfxfm(inst, et)

def ckfxfm_vector(k1, in11, in31):
    r"""ckfxfm_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in31)"""
    return _cspyce0.ckfxfm_vector(k1, in11, in31)

def ckgr02(handle, descr, recno):
    r"""ckgr02(SpiceInt handle, ConstSpiceDouble [5] descr, SpiceInt recno)"""
    return _cspyce0.ckgr02(handle, descr, recno)

def ckgr03(handle, descr, recno):
    r"""ckgr03(SpiceInt handle, ConstSpiceDouble [5] descr, SpiceInt recno)"""
    return _cspyce0.ckgr03(handle, descr, recno)

def cklpf(CONST_STRING):
    r"""cklpf(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.cklpf(CONST_STRING)

def ckmeta(ckid, CONST_STRING):
    r"""ckmeta(SpiceInt ckid, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.ckmeta(ckid, CONST_STRING)

def cknr02(handle, descr):
    r"""cknr02(SpiceInt handle, ConstSpiceDouble [5] descr)"""
    return _cspyce0.cknr02(handle, descr)

def cknr03(handle, descr):
    r"""cknr03(SpiceInt handle, ConstSpiceDouble [5] descr)"""
    return _cspyce0.cknr03(handle, descr)

def ckopn(arg1, arg2, ncomch):
    r"""ckopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt ncomch)"""
    return _cspyce0.ckopn(arg1, arg2, ncomch)

def ckupf(handle):
    r"""ckupf(SpiceInt handle)"""
    return _cspyce0.ckupf(handle)

def ckw01(handle, begtim, endtim, inst, arg5, avflag, arg7, nrec, quats, avvs):
    r"""ckw01(SpiceInt handle, SpiceDouble begtim, SpiceDouble endtim, SpiceInt inst, ConstSpiceChar * arg5, SpiceBoolean avflag, ConstSpiceChar * arg7, SpiceInt nrec, ConstSpiceDouble [][4] quats, ConstSpiceDouble [][3] avvs)"""
    return _cspyce0.ckw01(handle, begtim, endtim, inst, arg5, avflag, arg7, nrec, quats, avvs)

def ckw02(handle, begtim, endtim, inst, arg5, arg6, nrec, arg8, quats, avvs, arg11):
    r"""ckw02(SpiceInt handle, SpiceDouble begtim, SpiceDouble endtim, SpiceInt inst, ConstSpiceChar * arg5, ConstSpiceChar * arg6, SpiceInt nrec, ConstSpiceDouble * arg8, ConstSpiceDouble [][4] quats, ConstSpiceDouble [][3] avvs, ConstSpiceDouble * arg11)"""
    return _cspyce0.ckw02(handle, begtim, endtim, inst, arg5, arg6, nrec, arg8, quats, avvs, arg11)

def ckw03(handle, begtim, endtim, inst, arg5, avflag, arg7, nrec, quats, avvs, nints, IN_ARRAY1):
    r"""ckw03(SpiceInt handle, SpiceDouble begtim, SpiceDouble endtim, SpiceInt inst, ConstSpiceChar * arg5, SpiceBoolean avflag, ConstSpiceChar * arg7, SpiceInt nrec, ConstSpiceDouble [][4] quats, ConstSpiceDouble [][3] avvs, SpiceInt nints, ConstSpiceDouble * IN_ARRAY1)"""
    return _cspyce0.ckw03(handle, begtim, endtim, inst, arg5, avflag, arg7, nrec, quats, avvs, nints, IN_ARRAY1)

def ckw05(handle, subtyp, degree, begtim, endtim, inst, ref, avflag, segid, n, packts, rate, nints, starts):
    r"""ckw05(SpiceInt handle, ConstSpiceChar * subtyp, SpiceInt degree, SpiceDouble begtim, SpiceDouble endtim, SpiceInt inst, ConstSpiceChar * ref, SpiceBoolean avflag, ConstSpiceChar * segid, SpiceInt n, ConstSpiceDouble * packts, SpiceDouble rate, SpiceInt nints, ConstSpiceDouble * starts)"""
    return _cspyce0.ckw05(handle, subtyp, degree, begtim, endtim, inst, ref, avflag, segid, n, packts, rate, nints, starts)

def cmprss(delim, n, CONST_STRING):
    r"""cmprss(SpiceChar delim, SpiceInt n, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.cmprss(delim, n, CONST_STRING)

def cpos(arg1, arg2, start):
    r"""cpos(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"""
    return _cspyce0.cpos(arg1, arg2, start)

def cposr(arg1, arg2, start):
    r"""cposr(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"""
    return _cspyce0.cposr(arg1, arg2, start)

def cvpool(CONST_STRING):
    r"""cvpool(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.cvpool(CONST_STRING)

def dafac(handle, n):
    r"""dafac(SpiceInt handle, SpiceInt n)"""
    return _cspyce0.dafac(handle, n)

def dafbbs(handle):
    r"""dafbbs(SpiceInt handle)"""
    return _cspyce0.dafbbs(handle)

def dafcs(handle):
    r"""dafcs(SpiceInt handle)"""
    return _cspyce0.dafcs(handle)

def dafdc(handle):
    r"""dafdc(SpiceInt handle)"""
    return _cspyce0.dafdc(handle)

def dafec(handle):
    r"""dafec(SpiceInt handle)"""
    return _cspyce0.dafec(handle)

def daffpa():
    r"""daffpa()"""
    return _cspyce0.daffpa()

def dafgh():
    r"""dafgh()"""
    return _cspyce0.dafgh()

def dafgsr(handle, recno, begin, end):
    r"""dafgsr(SpiceInt handle, SpiceInt recno, SpiceInt begin, SpiceInt end)"""
    return _cspyce0.dafgsr(handle, recno, begin, end)

def dafhsf(handle):
    r"""dafhsf(SpiceInt handle)"""
    return _cspyce0.dafhsf(handle)

def dafopw(CONST_STRING):
    r"""dafopw(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.dafopw(CONST_STRING)

def dafps(nd, ni, nsum):
    r"""dafps(SpiceInt nd, SpiceInt ni, int * nsum)"""
    return _cspyce0.dafps(nd, ni, nsum)

def dafrfr(handle):
    r"""dafrfr(SpiceInt handle)"""
    return _cspyce0.dafrfr(handle)

def dafrs(sum):
    r"""dafrs(ConstSpiceDouble * sum)"""
    return _cspyce0.dafrs(sum)

def dasac(handle, n):
    r"""dasac(SpiceInt handle, SpiceInt n)"""
    return _cspyce0.dasac(handle, n)

def dasadc(handle, n, bpos, epos, datlen, data):
    r"""dasadc(SpiceInt handle, SpiceInt n, SpiceInt bpos, SpiceInt epos, SpiceInt datlen, ConstSpiceChar * data)"""
    return _cspyce0.dasadc(handle, n, bpos, epos, datlen, data)

def dasadd(handle, n):
    r"""dasadd(SpiceInt handle, SpiceInt n)"""
    return _cspyce0.dasadd(handle, n)

def dasadi(handle, n):
    r"""dasadi(SpiceInt handle, SpiceInt n)"""
    return _cspyce0.dasadi(handle, n)

def dascls(handle):
    r"""dascls(SpiceInt handle)"""
    return _cspyce0.dascls(handle)

def dasdc(handle):
    r"""dasdc(SpiceInt handle)"""
    return _cspyce0.dasdc(handle)

def dasec(handle):
    r"""dasec(SpiceInt handle)"""
    return _cspyce0.dasec(handle)

def dashfn(handle):
    r"""dashfn(SpiceInt handle)"""
    return _cspyce0.dashfn(handle)

def dashfs(handle):
    r"""dashfs(SpiceInt handle)"""
    return _cspyce0.dashfs(handle)

def daslla(handle):
    r"""daslla(SpiceInt handle)"""
    return _cspyce0.daslla(handle)

def dasllc(handle):
    r"""dasllc(SpiceInt handle)"""
    return _cspyce0.dasllc(handle)

def dasonw(arg1, arg2, arg3, ncomr):
    r"""dasonw(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceInt ncomr)"""
    return _cspyce0.dasonw(arg1, arg2, arg3, ncomr)

def dasopr(CONST_STRING):
    r"""dasopr(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.dasopr(CONST_STRING)

def dasops():
    r"""dasops()"""
    return _cspyce0.dasops()

def dasopw(CONST_STRING):
    r"""dasopw(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.dasopw(CONST_STRING)

def dasrdc(handle, first, last, bpos, epos, datlen, data):
    r"""dasrdc(SpiceInt handle, SpiceInt first, SpiceInt last, SpiceInt bpos, SpiceInt epos, SpiceInt datlen, char * data)"""
    return _cspyce0.dasrdc(handle, first, last, bpos, epos, datlen, data)

def dasrdd(handle, first, last):
    r"""dasrdd(SpiceInt handle, SpiceInt first, SpiceInt last)"""
    return _cspyce0.dasrdd(handle, first, last)

def dasrdi(handle, first, last):
    r"""dasrdi(SpiceInt handle, SpiceInt first, SpiceInt last)"""
    return _cspyce0.dasrdi(handle, first, last)

def dasrfr(handle):
    r"""dasrfr(SpiceInt handle)"""
    return _cspyce0.dasrfr(handle)

def dasudc(handle, first, last, bpos, epos, datlen, data):
    r"""dasudc(SpiceInt handle, SpiceInt first, SpiceInt last, SpiceInt bpos, SpiceInt epos, SpiceInt datlen, ConstSpiceChar * data)"""
    return _cspyce0.dasudc(handle, first, last, bpos, epos, datlen, data)

def dasudd(handle, first, last, IN_ARRAY1):
    r"""dasudd(SpiceInt handle, SpiceInt first, SpiceInt last, ConstSpiceDouble * IN_ARRAY1)"""
    return _cspyce0.dasudd(handle, first, last, IN_ARRAY1)

def dasudi(handle, first, last, IN_ARRAY1):
    r"""dasudi(SpiceInt handle, SpiceInt first, SpiceInt last, ConstSpiceInt * IN_ARRAY1)"""
    return _cspyce0.dasudi(handle, first, last, IN_ARRAY1)

def daswbr(handle):
    r"""daswbr(SpiceInt handle)"""
    return _cspyce0.daswbr(handle)

def dazldr(x, y, z, azccw, elplsz):
    r"""dazldr(SpiceDouble x, SpiceDouble y, SpiceDouble z, SpiceBoolean azccw, SpiceBoolean elplsz)"""
    return _cspyce0.dazldr(x, y, z, azccw, elplsz)

def dazldr_vector(in11, in12, in13, b1, b2):
    r"""dazldr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, SpiceBoolean b1, SpiceBoolean b2)"""
    return _cspyce0.dazldr_vector(in11, in12, in13, b1, b2)

def dlabbs(handle):
    r"""dlabbs(SpiceInt handle)"""
    return _cspyce0.dlabbs(handle)

def dlabfs(handle):
    r"""dlabfs(SpiceInt handle)"""
    return _cspyce0.dlabfs(handle)

def dlabns(handle):
    r"""dlabns(SpiceInt handle)"""
    return _cspyce0.dlabns(handle)

def dlaens(handle):
    r"""dlaens(SpiceInt handle)"""
    return _cspyce0.dlaens(handle)

def dlafns(handle, dladsc):
    r"""dlafns(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc)"""
    return _cspyce0.dlafns(handle, dladsc)

def dlafps(handle, dladsc):
    r"""dlafps(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc)"""
    return _cspyce0.dlafps(handle, dladsc)

def dlaopn(arg1, arg2, arg3, ncomch):
    r"""dlaopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceInt ncomch)"""
    return _cspyce0.dlaopn(arg1, arg2, arg3, ncomch)

def dnearp(state, a, b, c):
    r"""dnearp(ConstSpiceDouble [6] state, SpiceDouble a, SpiceDouble b, SpiceDouble c)"""
    return _cspyce0.dnearp(state, a, b, c)

def dnearp_vector(in21, in11, in12, in13):
    r"""dnearp_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.dnearp_vector(in21, in11, in12, in13)

def dp2hx(number, hxstr):
    r"""dp2hx(SpiceDouble number, SpiceChar [256] hxstr)"""
    return _cspyce0.dp2hx(number, hxstr)

def drdazl(range, az, el, azccw, elplsz):
    r"""drdazl(SpiceDouble range, SpiceDouble az, SpiceDouble el, SpiceBoolean azccw, SpiceBoolean elplsz)"""
    return _cspyce0.drdazl(range, az, el, azccw, elplsz)

def drdazl_vector(in11, in12, in13, b1, b2):
    r"""drdazl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, SpiceBoolean b1, SpiceBoolean b2)"""
    return _cspyce0.drdazl_vector(in11, in12, in13, b1, b2)

def dskb02(handle, dladsc):
    r"""dskb02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc)"""
    return _cspyce0.dskb02(handle, dladsc)

def dskcls(handle, optmiz):
    r"""dskcls(SpiceInt handle, SpiceBoolean optmiz)"""
    return _cspyce0.dskcls(handle, optmiz)

def dskd02(handle, dladsc, item, start):
    r"""dskd02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, SpiceInt item, SpiceInt start)"""
    return _cspyce0.dskd02(handle, dladsc, item, start)

def dskgd(handle, dladsc):
    r"""dskgd(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc)"""
    return _cspyce0.dskgd(handle, dladsc)

def dskgtl(keywrd):
    r"""dskgtl(SpiceInt keywrd)"""
    return _cspyce0.dskgtl(keywrd)

def dski02(handle, dladsc, item, start, room):
    r"""dski02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, SpiceInt item, SpiceInt start, SpiceInt room)"""
    return _cspyce0.dski02(handle, dladsc, item, start, room)

def dskmi2(nv, np, finscl, corscl, makvtl):
    r"""dskmi2(SpiceInt nv, SpiceInt np, SpiceDouble finscl, SpiceInt corscl, SpiceBoolean makvtl)"""
    return _cspyce0.dskmi2(nv, np, finscl, corscl, makvtl)

def dskn02(handle, dladsc, plid):
    r"""dskn02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, SpiceInt plid)"""
    return _cspyce0.dskn02(handle, dladsc, plid)

def dskobj(dskfnm):
    r"""dskobj(ConstSpiceChar * dskfnm)"""
    return _cspyce0.dskobj(dskfnm)

def dskopn(arg1, arg2, ncomch):
    r"""dskopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt ncomch)"""
    return _cspyce0.dskopn(arg1, arg2, ncomch)

def dskp02(handle, dladsc, start, room, n, plates):
    r"""dskp02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, SpiceInt start, SpiceInt room, SpiceInt * n, SpiceInt [NPLATES][3] plates)"""
    return _cspyce0.dskp02(handle, dladsc, start, room, n, plates)

def dskrb2(nv, np, corsys, IN_ARRAY1):
    r"""dskrb2(SpiceInt nv, SpiceInt np, SpiceInt corsys, ConstSpiceDouble * IN_ARRAY1)"""
    return _cspyce0.dskrb2(nv, np, corsys, IN_ARRAY1)

def dsksrf(dskfnm, bodyid):
    r"""dsksrf(ConstSpiceChar * dskfnm, SpiceInt bodyid)"""
    return _cspyce0.dsksrf(dskfnm, bodyid)

def dskstl(keywrd, dpval):
    r"""dskstl(SpiceInt keywrd, SpiceDouble dpval)"""
    return _cspyce0.dskstl(keywrd, dpval)

def dskv02(handle, dladsc, start, room, n, vrtces):
    r"""dskv02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, SpiceInt start, SpiceInt room, SpiceInt * n, SpiceDouble [NPLATES][3] vrtces)"""
    return _cspyce0.dskv02(handle, dladsc, start, room, n, vrtces)

def dskw02(handle, center, surfid, dclass, CONST_STRING, corsys, corpar, mncor1, mxcor1, mncor2, mxcor2, mncor3, mxcor3, first, last, nv, np, spaixd, spaixi):
    r"""dskw02(SpiceInt handle, SpiceInt center, SpiceInt surfid, SpiceInt dclass, ConstSpiceChar * CONST_STRING, SpiceInt corsys, ConstSpiceDouble [] corpar, SpiceDouble mncor1, SpiceDouble mxcor1, SpiceDouble mncor2, SpiceDouble mxcor2, SpiceDouble mncor3, SpiceDouble mxcor3, SpiceDouble first, SpiceDouble last, SpiceInt nv, SpiceInt np, ConstSpiceDouble [] spaixd, ConstSpiceInt [] spaixi)"""
    return _cspyce0.dskw02(handle, center, surfid, dclass, CONST_STRING, corsys, corpar, mncor1, mxcor1, mncor2, mxcor2, mncor3, mxcor3, first, last, nv, np, spaixd, spaixi)

def dskx02(handle, dladsc, vertex, raydir):
    r"""dskx02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, ConstSpiceDouble [3] vertex, ConstSpiceDouble [3] raydir)"""
    return _cspyce0.dskx02(handle, dladsc, vertex, raydir)

def dskxsi(pri, target, nsurf, srflst, et, fixref, vertex, raydir):
    r"""dskxsi(SpiceBoolean pri, ConstSpiceChar * target, SpiceInt nsurf, ConstSpiceInt [] srflst, SpiceDouble et, ConstSpiceChar * fixref, ConstSpiceDouble [3] vertex, ConstSpiceDouble [3] raydir)"""
    return _cspyce0.dskxsi(pri, target, nsurf, srflst, et, fixref, vertex, raydir)

def dskxv(pri, target, nsurf, et, fixref, nrays, n2, n3, nv, xptarr, n4, fndarr):
    r"""dskxv(SpiceBoolean pri, ConstSpiceChar * target, SpiceInt nsurf, SpiceDouble et, ConstSpiceChar * fixref, SpiceInt nrays, SpiceInt n2, SpiceInt * n3, SpiceInt * nv, SpiceDouble ** xptarr, SpiceInt * n4, SpiceBoolean ** fndarr)"""
    return _cspyce0.dskxv(pri, target, nsurf, et, fixref, nrays, n2, n3, nv, xptarr, n4, fndarr)

def dskz02(handle, dladsc):
    r"""dskz02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc)"""
    return _cspyce0.dskz02(handle, dladsc)

def ednmpt(a, b, c, normal):
    r"""ednmpt(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [3] normal)"""
    return _cspyce0.ednmpt(a, b, c, normal)

def ednmpt_vector(in11, in12, in13, in21):
    r"""ednmpt_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in21)"""
    return _cspyce0.ednmpt_vector(in11, in12, in13, in21)

def edpnt(p, a, b, c):
    r"""edpnt(ConstSpiceDouble [3] p, SpiceDouble a, SpiceDouble b, SpiceDouble c)"""
    return _cspyce0.edpnt(p, a, b, c)

def edpnt_vector(in21, in11, in12, in13):
    r"""edpnt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
    return _cspyce0.edpnt_vector(in21, in11, in12, in13)

def ekacec(handle, segno, recno, CONST_STRING, nvals, isnull):
    r"""ekacec(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, SpiceBoolean isnull)"""
    return _cspyce0.ekacec(handle, segno, recno, CONST_STRING, nvals, isnull)

def ekaced(handle, segno, recno, CONST_STRING, nvals, dvals, isnull):
    r"""ekaced(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, ConstSpiceDouble [] dvals, SpiceBoolean isnull)"""
    return _cspyce0.ekaced(handle, segno, recno, CONST_STRING, nvals, dvals, isnull)

def ekacei(handle, segno, recno, CONST_STRING, nvals, ivals, isnull):
    r"""ekacei(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, ConstSpiceInt [] ivals, SpiceBoolean isnull)"""
    return _cspyce0.ekacei(handle, segno, recno, CONST_STRING, nvals, ivals, isnull)

def ekaclc(handle, segno, column, vallen, cvals, entszs, nlflgs, rcptrs):
    r"""ekaclc(SpiceInt handle, SpiceInt segno, ConstSpiceChar * column, SpiceInt vallen, ConstSpiceChar * cvals, ConstSpiceInt [] entszs, ConstSpiceBoolean [] nlflgs, ConstSpiceInt [] rcptrs)"""
    return _cspyce0.ekaclc(handle, segno, column, vallen, cvals, entszs, nlflgs, rcptrs)

def ekacld(handle, segno, column, dvals, entszs, nlflgs, rcptrs):
    r"""ekacld(SpiceInt handle, SpiceInt segno, ConstSpiceChar * column, ConstSpiceDouble [] dvals, ConstSpiceInt [] entszs, ConstSpiceBoolean [] nlflgs, ConstSpiceInt [] rcptrs)"""
    return _cspyce0.ekacld(handle, segno, column, dvals, entszs, nlflgs, rcptrs)

def ekacli(handle, segno, column, ivals, entszs, nlflgs, rcptrs):
    r"""ekacli(SpiceInt handle, SpiceInt segno, ConstSpiceChar * column, ConstSpiceInt [] ivals, ConstSpiceInt [] entszs, ConstSpiceBoolean [] nlflgs, ConstSpiceInt [] rcptrs)"""
    return _cspyce0.ekacli(handle, segno, column, ivals, entszs, nlflgs, rcptrs)

def ekappr(handle, segno):
    r"""ekappr(SpiceInt handle, SpiceInt segno)"""
    return _cspyce0.ekappr(handle, segno)

def ekbseg(handle, CONST_STRING, ncols, declen, decls):
    r"""ekbseg(SpiceInt handle, ConstSpiceChar * CONST_STRING, SpiceInt ncols, SpiceInt declen, ConstSpiceChar * decls)"""
    return _cspyce0.ekbseg(handle, CONST_STRING, ncols, declen, decls)

def ekccnt(CONST_STRING):
    r"""ekccnt(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.ekccnt(CONST_STRING)

def ekcii(table, cindex):
    r"""ekcii(ConstSpiceChar * table, SpiceInt cindex)"""
    return _cspyce0.ekcii(table, cindex)

def ekcls(handle):
    r"""ekcls(SpiceInt handle)"""
    return _cspyce0.ekcls(handle)

def ekdelr(handle, segno, recno):
    r"""ekdelr(SpiceInt handle, SpiceInt segno, SpiceInt recno)"""
    return _cspyce0.ekdelr(handle, segno, recno)

def ekffld(handle, segno, rcptrs):
    r"""ekffld(SpiceInt handle, SpiceInt segno, SpiceInt [] rcptrs)"""
    return _cspyce0.ekffld(handle, segno, rcptrs)

def ekfind(query):
    r"""ekfind(ConstSpiceChar * query)"""
    return _cspyce0.ekfind(query)

def ekgc(selidx, row, elment):
    r"""ekgc(SpiceInt selidx, SpiceInt row, SpiceInt elment)"""
    return _cspyce0.ekgc(selidx, row, elment)

def ekgd(selidx, row, elment):
    r"""ekgd(SpiceInt selidx, SpiceInt row, SpiceInt elment)"""
    return _cspyce0.ekgd(selidx, row, elment)

def ekgi(selidx, row, elment):
    r"""ekgi(SpiceInt selidx, SpiceInt row, SpiceInt elment)"""
    return _cspyce0.ekgi(selidx, row, elment)

def ekifld(handle, tabnam, nrows, ncols, declen, decls):
    r"""ekifld(SpiceInt handle, ConstSpiceChar * tabnam, SpiceInt nrows, SpiceInt ncols, SpiceInt declen, ConstSpiceChar * decls)"""
    return _cspyce0.ekifld(handle, tabnam, nrows, ncols, declen, decls)

def ekinsr(handle, segno, recno):
    r"""ekinsr(SpiceInt handle, SpiceInt segno, SpiceInt recno)"""
    return _cspyce0.ekinsr(handle, segno, recno)

def eklef(CONST_STRING):
    r"""eklef(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.eklef(CONST_STRING)

def eknelt(selidx, row):
    r"""eknelt(SpiceInt selidx, SpiceInt row) -> SpiceInt"""
    return _cspyce0.eknelt(selidx, row)

def eknseg(handle):
    r"""eknseg(SpiceInt handle) -> SpiceInt"""
    return _cspyce0.eknseg(handle)

def ekntab():
    r"""ekntab()"""
    return _cspyce0.ekntab()

def ekopn(arg1, arg2, ncomch):
    r"""ekopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt ncomch)"""
    return _cspyce0.ekopn(arg1, arg2, ncomch)

def ekopr(CONST_STRING):
    r"""ekopr(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.ekopr(CONST_STRING)

def ekops():
    r"""ekops()"""
    return _cspyce0.ekops()

def ekopw(CONST_STRING):
    r"""ekopw(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.ekopw(CONST_STRING)

def ekpsel(query, tabs, n4, cols, n5):
    r"""ekpsel(ConstSpiceChar * query, char [CLAUSES][NAMELEN] tabs, int * n4, char [CLAUSES][NAMELEN] cols, int * n5)"""
    return _cspyce0.ekpsel(query, tabs, n4, cols, n5)

def ekrcec(handle, segno, recno, CONST_STRING, cvalen, nvals, cvals):
    r"""ekrcec(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt cvalen, SpiceInt * nvals, char [MAXVALS][COLLEN] cvals)"""
    return _cspyce0.ekrcec(handle, segno, recno, CONST_STRING, cvalen, nvals, cvals)

def ekrced(handle, segno, recno, CONST_STRING):
    r"""ekrced(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.ekrced(handle, segno, recno, CONST_STRING)

def ekrcei(handle, segno, recno, CONST_STRING):
    r"""ekrcei(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.ekrcei(handle, segno, recno, CONST_STRING)

def ekssum(handle, segno, nrows, cnames, n1):
    r"""ekssum(SpiceInt handle, SpiceInt segno, int * nrows, SpiceChar [SPICE_EK_MXCLSG][NAMELEN] cnames, int * n1)"""
    return _cspyce0.ekssum(handle, segno, nrows, cnames, n1)

def ektnam(n):
    r"""ektnam(SpiceInt n)"""
    return _cspyce0.ektnam(n)

def ekucec(handle, segno, recno, CONST_STRING, nvals, isnull):
    r"""ekucec(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, SpiceBoolean isnull)"""
    return _cspyce0.ekucec(handle, segno, recno, CONST_STRING, nvals, isnull)

def ekuced(handle, segno, recno, CONST_STRING, nvals, dvals, isnull):
    r"""ekuced(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, ConstSpiceDouble [] dvals, SpiceBoolean isnull)"""
    return _cspyce0.ekuced(handle, segno, recno, CONST_STRING, nvals, dvals, isnull)

def ekucei(handle, segno, recno, CONST_STRING, nvals, ivals, isnull):
    r"""ekucei(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, ConstSpiceInt [] ivals, SpiceBoolean isnull)"""
    return _cspyce0.ekucei(handle, segno, recno, CONST_STRING, nvals, ivals, isnull)

def ekuef(handle):
    r"""ekuef(SpiceInt handle)"""
    return _cspyce0.ekuef(handle)

def evsgp4(et, geophs, elems):
    r"""evsgp4(SpiceDouble et, ConstSpiceDouble [8] geophs, ConstSpiceDouble [10] elems)"""
    return _cspyce0.evsgp4(et, geophs, elems)

def evsgp4_vector(in11, in21, in22):
    r"""evsgp4_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.evsgp4_vector(in11, in21, in22)

def esrchc(CONST_STRING, ndim):
    r"""esrchc(ConstSpiceChar * CONST_STRING, SpiceInt ndim) -> SpiceInt"""
    return _cspyce0.esrchc(CONST_STRING, ndim)

def getelm(frstyr, two):
    r"""getelm(SpiceInt frstyr, SpiceInt two)"""
    return _cspyce0.getelm(frstyr, two)

def getfat(file):
    r"""getfat(ConstSpiceChar * file)"""
    return _cspyce0.getfat(file)

def getfvn(inst):
    r"""getfvn(ConstSpiceChar * inst)"""
    return _cspyce0.getfvn(inst)

def gfdist(target, abcorr, obsrvr, relate, refval, adjust, step, et0, et1):
    r"""gfdist(ConstSpiceChar * target, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, ConstSpiceChar * relate, SpiceDouble refval, SpiceDouble adjust, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfdist(target, abcorr, obsrvr, relate, refval, adjust, step, et0, et1)

def gfevnt(step, gquant, qnpars, qpnams, qcpars, qdpars, qipars, qlpars, op, refval, tol, adjust, rpt, et0, et1):
    r"""gfevnt(SpiceDouble step, ConstSpiceChar * gquant, SpiceInt qnpars, ConstSpiceChar * qpnams, ConstSpiceChar * qcpars, ConstSpiceDouble * qdpars, ConstSpiceInt * qipars, ConstSpiceBoolean * qlpars, ConstSpiceChar * op, SpiceDouble refval, SpiceDouble tol, SpiceDouble adjust, SpiceBoolean rpt, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfevnt(step, gquant, qnpars, qpnams, qcpars, qdpars, qipars, qlpars, op, refval, tol, adjust, rpt, et0, et1)

def gffove(inst, tshape, raydir, target, tframe, abcorr, obsrvr, tol, step, rpt, et0, et1):
    r"""gffove(ConstSpiceChar * inst, ConstSpiceChar * tshape, ConstSpiceDouble [3] raydir, ConstSpiceChar * target, ConstSpiceChar * tframe, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceDouble tol, SpiceDouble step, SpiceBoolean rpt, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gffove(inst, tshape, raydir, target, tframe, abcorr, obsrvr, tol, step, rpt, et0, et1)

def gfilum(method, angtyp, target, illmn, fixref, abcorr, obsrvr, spoint, relate, refval, adjust, step, et0, et1):
    r"""gfilum(ConstSpiceChar * method, ConstSpiceChar * angtyp, ConstSpiceChar * target, ConstSpiceChar * illmn, ConstSpiceChar * fixref, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, ConstSpiceDouble [3] spoint, ConstSpiceChar * relate, SpiceDouble refval, SpiceDouble adjust, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfilum(method, angtyp, target, illmn, fixref, abcorr, obsrvr, spoint, relate, refval, adjust, step, et0, et1)

def gfocce(occtyp, front, fshape, fframe, back, bshape, bframe, abcorr, obsrvr, tol, step, rpt, et0, et1):
    r"""gfocce(ConstSpiceChar * occtyp, ConstSpiceChar * front, ConstSpiceChar * fshape, ConstSpiceChar * fframe, ConstSpiceChar * back, ConstSpiceChar * bshape, ConstSpiceChar * bframe, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceDouble tol, SpiceDouble step, SpiceBoolean rpt, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfocce(occtyp, front, fshape, fframe, back, bshape, bframe, abcorr, obsrvr, tol, step, rpt, et0, et1)

def gfoclt(occtyp, front, fshape, fframe, back, bshape, bframe, abcorr, obsrvr, step, et0, et1):
    r"""gfoclt(ConstSpiceChar * occtyp, ConstSpiceChar * front, ConstSpiceChar * fshape, ConstSpiceChar * fframe, ConstSpiceChar * back, ConstSpiceChar * bshape, ConstSpiceChar * bframe, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfoclt(occtyp, front, fshape, fframe, back, bshape, bframe, abcorr, obsrvr, step, et0, et1)

def gfpa(target, illmn, abcorr, obsrvr, relate, refval, adjust, step, et0, et1):
    r"""gfpa(ConstSpiceChar * target, ConstSpiceChar * illmn, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, ConstSpiceChar * relate, SpiceDouble refval, SpiceDouble adjust, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfpa(target, illmn, abcorr, obsrvr, relate, refval, adjust, step, et0, et1)

def gfposc(target, frame, abcorr, obsrvr, crdsys, coord, relate, refval, adjust, step, et0, et1):
    r"""gfposc(ConstSpiceChar * target, ConstSpiceChar * frame, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, ConstSpiceChar * crdsys, ConstSpiceChar * coord, ConstSpiceChar * relate, SpiceDouble refval, SpiceDouble adjust, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfposc(target, frame, abcorr, obsrvr, crdsys, coord, relate, refval, adjust, step, et0, et1)

def gfrfov(inst, raydir, rframe, abcorr, obsrvr, step, et0, et1):
    r"""gfrfov(ConstSpiceChar * inst, ConstSpiceDouble [3] raydir, ConstSpiceChar * rframe, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfrfov(inst, raydir, rframe, abcorr, obsrvr, step, et0, et1)

def gfrr(target, abcorr, obsrvr, relate, refval, adjust, step, et0, et1):
    r"""gfrr(ConstSpiceChar * target, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, ConstSpiceChar * relate, SpiceDouble refval, SpiceDouble adjust, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfrr(target, abcorr, obsrvr, relate, refval, adjust, step, et0, et1)

def gfsep(targ1, shape1, frame1, targ2, shape2, frame2, abcorr, obsrvr, relate, refval, adjust, step, et0, et1):
    r"""gfsep(ConstSpiceChar * targ1, ConstSpiceChar * shape1, ConstSpiceChar * frame1, ConstSpiceChar * targ2, ConstSpiceChar * shape2, ConstSpiceChar * frame2, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, ConstSpiceChar * relate, SpiceDouble refval, SpiceDouble adjust, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfsep(targ1, shape1, frame1, targ2, shape2, frame2, abcorr, obsrvr, relate, refval, adjust, step, et0, et1)

def gfsntc(target, fixref, method, abcorr, obsrvr, dref, dvec, crdsys, coord, relate, refval, adjust, step, et0, et1):
    r"""gfsntc(ConstSpiceChar * target, ConstSpiceChar * fixref, ConstSpiceChar * method, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, ConstSpiceChar * dref, ConstSpiceDouble [3] dvec, ConstSpiceChar * crdsys, ConstSpiceChar * coord, ConstSpiceChar * relate, SpiceDouble refval, SpiceDouble adjust, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfsntc(target, fixref, method, abcorr, obsrvr, dref, dvec, crdsys, coord, relate, refval, adjust, step, et0, et1)

def gfstol(value):
    r"""gfstol(SpiceDouble value)"""
    return _cspyce0.gfstol(value)

def gfsubc(target, fixref, method, abcorr, obsrvr, crdsys, coord, relate, refval, adjust, step, et0, et1):
    r"""gfsubc(ConstSpiceChar * target, ConstSpiceChar * fixref, ConstSpiceChar * method, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, ConstSpiceChar * crdsys, ConstSpiceChar * coord, ConstSpiceChar * relate, SpiceDouble refval, SpiceDouble adjust, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gfsubc(target, fixref, method, abcorr, obsrvr, crdsys, coord, relate, refval, adjust, step, et0, et1)

def gftfov(inst, target, tshape, tframe, abcorr, obsrvr, step, et0, et1):
    r"""gftfov(ConstSpiceChar * inst, ConstSpiceChar * target, ConstSpiceChar * tshape, ConstSpiceChar * tframe, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"""
    return _cspyce0.gftfov(inst, target, tshape, tframe, abcorr, obsrvr, step, et0, et1)

def hrmesp(first, step, yvals, x):
    r"""hrmesp(SpiceDouble first, SpiceDouble step, ConstSpiceDouble * yvals, SpiceDouble x)"""
    return _cspyce0.hrmesp(first, step, yvals, x)

def hrmesp_vector(in11, in12, in21, in13):
    r"""hrmesp_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in21, ConstSpiceDouble * in13)"""
    return _cspyce0.hrmesp_vector(in11, in12, in21, in13)

def hrmint(xvals, yvals, x):
    r"""hrmint(ConstSpiceDouble * xvals, ConstSpiceDouble * yvals, SpiceDouble x)"""
    return _cspyce0.hrmint(xvals, yvals, x)

def hrmint_vector(in21, in31, in11):
    r"""hrmint_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in31, ConstSpiceDouble * in11)"""
    return _cspyce0.hrmint_vector(in21, in31, in11)

def hx2dp(string):
    r"""hx2dp(ConstSpiceChar * string)"""
    return _cspyce0.hx2dp(string)

def invstm(mat):
    r"""invstm(ConstSpiceDouble [6][6] mat)"""
    return _cspyce0.invstm(mat)

def invstm_vector(in31):
    r"""invstm_vector(ConstSpiceDouble * in31)"""
    return _cspyce0.invstm_vector(in31)

def isrchc(CONST_STRING, ndim):
    r"""isrchc(ConstSpiceChar * CONST_STRING, SpiceInt ndim) -> SpiceInt"""
    return _cspyce0.isrchc(CONST_STRING, ndim)

def isrchd(value, ndim):
    r"""isrchd(SpiceDouble value, SpiceInt ndim) -> SpiceInt"""
    return _cspyce0.isrchd(value, ndim)

def isrchi(value, ndim):
    r"""isrchi(SpiceInt value, SpiceInt ndim) -> SpiceInt"""
    return _cspyce0.isrchi(value, ndim)

def isordv(array, n):
    r"""isordv(ConstSpiceInt [] array, SpiceInt n) -> SpiceBoolean"""
    return _cspyce0.isordv(array, n)

def iswhsp(CONST_STRING):
    r"""iswhsp(ConstSpiceChar * CONST_STRING) -> SpiceBoolean"""
    return _cspyce0.iswhsp(CONST_STRING)

def kclear():
    r"""kclear()"""
    return _cspyce0.kclear()

def kdata(which, kind):
    r"""kdata(SpiceInt which, ConstSpiceChar * kind)"""
    return _cspyce0.kdata(which, kind)

def kinfo(file):
    r"""kinfo(ConstSpiceChar * file)"""
    return _cspyce0.kinfo(file)

def ktotal(CONST_STRING):
    r"""ktotal(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.ktotal(CONST_STRING)

def kxtrct(keywd, nterms, worlen):
    r"""kxtrct(ConstSpiceChar * keywd, SpiceInt nterms, SpiceInt worlen)"""
    return _cspyce0.kxtrct(keywd, nterms, worlen)

def lgresp(first, step, yvals, x):
    r"""lgresp(SpiceDouble first, SpiceDouble step, ConstSpiceDouble * yvals, SpiceDouble x) -> SpiceDouble"""
    return _cspyce0.lgresp(first, step, yvals, x)

def lgresp_vector(in11, in12, in21, in13):
    r"""lgresp_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in21, ConstSpiceDouble * in13)"""
    return _cspyce0.lgresp_vector(in11, in12, in21, in13)

def lgrind(xvals, yvals, x):
    r"""lgrind(ConstSpiceDouble * xvals, ConstSpiceDouble * yvals, SpiceDouble x)"""
    return _cspyce0.lgrind(xvals, yvals, x)

def lgrind_vector(in21, in22, in11):
    r"""lgrind_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"""
    return _cspyce0.lgrind_vector(in21, in22, in11)

def lgrint(xvals, yvals, x):
    r"""lgrint(ConstSpiceDouble * xvals, ConstSpiceDouble * yvals, SpiceDouble x) -> SpiceDouble"""
    return _cspyce0.lgrint(xvals, yvals, x)

def lgrint_vector(in21, in22, in11):
    r"""lgrint_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"""
    return _cspyce0.lgrint_vector(in21, in22, in11)

def lmpool(cvals):
    r"""lmpool(ConstSpiceChar * cvals)"""
    return _cspyce0.lmpool(cvals)

def lparse(arg1, arg2):
    r"""lparse(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"""
    return _cspyce0.lparse(arg1, arg2)

def lparsm(arg1, arg2):
    r"""lparsm(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"""
    return _cspyce0.lparsm(arg1, arg2)

def lstlec(CONST_STRING, n):
    r"""lstlec(ConstSpiceChar * CONST_STRING, SpiceInt n) -> SpiceInt"""
    return _cspyce0.lstlec(CONST_STRING, n)

def lstled(x, n):
    r"""lstled(SpiceDouble x, SpiceInt n) -> SpiceInt"""
    return _cspyce0.lstled(x, n)

def lstlei(x, n):
    r"""lstlei(SpiceInt x, SpiceInt n) -> SpiceInt"""
    return _cspyce0.lstlei(x, n)

def lstltc(CONST_STRING, n):
    r"""lstltc(ConstSpiceChar * CONST_STRING, SpiceInt n) -> SpiceInt"""
    return _cspyce0.lstltc(CONST_STRING, n)

def lstltd(x, n):
    r"""lstltd(SpiceDouble x, SpiceInt n) -> SpiceInt"""
    return _cspyce0.lstltd(x, n)

def lstlti(x, n):
    r"""lstlti(SpiceInt x, SpiceInt n) -> SpiceInt"""
    return _cspyce0.lstlti(x, n)

def lx4dec(CONST_STRING, first):
    r"""lx4dec(ConstSpiceChar * CONST_STRING, SpiceInt first)"""
    return _cspyce0.lx4dec(CONST_STRING, first)

def lx4num(CONST_STRING, first):
    r"""lx4num(ConstSpiceChar * CONST_STRING, SpiceInt first)"""
    return _cspyce0.lx4num(CONST_STRING, first)

def lx4sgn(CONST_STRING, first):
    r"""lx4sgn(ConstSpiceChar * CONST_STRING, SpiceInt first)"""
    return _cspyce0.lx4sgn(CONST_STRING, first)

def lx4uns(CONST_STRING, first):
    r"""lx4uns(ConstSpiceChar * CONST_STRING, SpiceInt first)"""
    return _cspyce0.lx4uns(CONST_STRING, first)

def lxqstr(CONST_STRING, IN_STRING, first):
    r"""lxqstr(ConstSpiceChar * CONST_STRING, SpiceChar IN_STRING, SpiceInt first)"""
    return _cspyce0.lxqstr(CONST_STRING, IN_STRING, first)

def matchi(arg1, arg2, arg3, arg4):
    r"""matchi(ConstSpiceChar * arg1, SpiceChar * arg2, SpiceChar arg3, SpiceChar arg4)"""
    return _cspyce0.matchi(arg1, arg2, arg3, arg4)

def matchw(arg1, arg2, arg3, arg4):
    r"""matchw(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceChar arg3, SpiceChar arg4)"""
    return _cspyce0.matchw(arg1, arg2, arg3, arg4)

def ncpos(arg1, arg2, start):
    r"""ncpos(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"""
    return _cspyce0.ncpos(arg1, arg2, start)

def ncposr(arg1, arg2, start):
    r"""ncposr(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"""
    return _cspyce0.ncposr(arg1, arg2, start)

def nextwd(string):
    r"""nextwd(ConstSpiceChar * string)"""
    return _cspyce0.nextwd(string)

def nthwd(CONST_STRING, nth):
    r"""nthwd(ConstSpiceChar * CONST_STRING, SpiceInt nth)"""
    return _cspyce0.nthwd(CONST_STRING, nth)

def orderc(ndim, n, iorder):
    r"""orderc(SpiceInt ndim, SpiceInt * n, SpiceInt ** iorder)"""
    return _cspyce0.orderc(ndim, n, iorder)

def orderd(array, n, iorder):
    r"""orderd(ConstSpiceDouble * array, SpiceInt * n, SpiceInt ** iorder)"""
    return _cspyce0.orderd(array, n, iorder)

def orderi(array, n, iorder):
    r"""orderi(ConstSpiceInt * array, SpiceInt * n, SpiceInt ** iorder)"""
    return _cspyce0.orderi(array, n, iorder)

def pckcls(handle):
    r"""pckcls(SpiceInt handle)"""
    return _cspyce0.pckcls(handle)

def pcklof(CONST_STRING):
    r"""pcklof(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.pcklof(CONST_STRING)

def pckopn(arg1, arg2, ncomch):
    r"""pckopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt ncomch)"""
    return _cspyce0.pckopn(arg1, arg2, ncomch)

def pckuof(handle):
    r"""pckuof(SpiceInt handle)"""
    return _cspyce0.pckuof(handle)

def pckw02(handle, clssid, arg3, first, last, arg6, intlen, n, polydg, IN_ARRAY1, btime):
    r"""pckw02(SpiceInt handle, SpiceInt clssid, ConstSpiceChar * arg3, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg6, SpiceDouble intlen, SpiceInt n, SpiceInt polydg, SpiceDouble * IN_ARRAY1, SpiceDouble btime)"""
    return _cspyce0.pckw02(handle, clssid, arg3, first, last, arg6, intlen, n, polydg, IN_ARRAY1, btime)

def pltnrm(v1, v2, v3):
    r"""pltnrm(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2, ConstSpiceDouble [3] v3)"""
    return _cspyce0.pltnrm(v1, v2, v3)

def pltnrm_vector(in21, in22, in23):
    r"""pltnrm_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"""
    return _cspyce0.pltnrm_vector(in21, in22, in23)

def polyds(deg_plus_1, nderiv, t):
    r"""polyds(SpiceInt deg_plus_1, SpiceInt nderiv, SpiceDouble t)"""
    return _cspyce0.polyds(deg_plus_1, nderiv, t)

def polyds_vector(in21, nderiv, in12):
    r"""polyds_vector(ConstSpiceDouble * in21, SpiceInt nderiv, ConstSpiceDouble * in12)"""
    return _cspyce0.polyds_vector(in21, nderiv, in12)

def pos(arg1, arg2, start):
    r"""pos(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"""
    return _cspyce0.pos(arg1, arg2, start)

def posr(arg1, arg2, start):
    r"""posr(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"""
    return _cspyce0.posr(arg1, arg2, start)

def prompt(CONST_STRING):
    r"""prompt(ConstSpiceChar * CONST_STRING) -> SpiceChar *"""
    return _cspyce0.prompt(CONST_STRING)

def prsdp(CONST_STRING):
    r"""prsdp(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.prsdp(CONST_STRING)

def prsint(CONST_STRING):
    r"""prsint(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.prsint(CONST_STRING)

def qderiv(ndim, ndim1, delta, ndim2, dfdt):
    r"""qderiv(SpiceInt ndim, SpiceInt ndim1, SpiceDouble delta, SpiceInt * ndim2, SpiceDouble ** dfdt)"""
    return _cspyce0.qderiv(ndim, ndim1, delta, ndim2, dfdt)

def recazl(rectan, azccw, elplsz):
    r"""recazl(ConstSpiceDouble [3] rectan, SpiceBoolean azccw, SpiceBoolean elplsz)"""
    return _cspyce0.recazl(rectan, azccw, elplsz)

def recazl_vector(in21, in11, in12):
    r"""recazl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
    return _cspyce0.recazl_vector(in21, in11, in12)

def reordc(iorder, ndim):
    r"""reordc(ConstSpiceInt * iorder, SpiceInt ndim)"""
    return _cspyce0.reordc(iorder, ndim)

def reordd(iorder, ndim, array):
    r"""reordd(ConstSpiceInt * iorder, SpiceInt ndim, SpiceDouble * array)"""
    return _cspyce0.reordd(iorder, ndim, array)

def reordi(iorder, ndim, array):
    r"""reordi(ConstSpiceInt * iorder, SpiceInt ndim, SpiceInt * array)"""
    return _cspyce0.reordi(iorder, ndim, array)

def reordl(iorder, ndim, array):
    r"""reordl(ConstSpiceInt * iorder, SpiceInt ndim, SpiceBoolean * array)"""
    return _cspyce0.reordl(iorder, ndim, array)

def repml(arg1, arg2, value, IN_STRING):
    r"""repml(ConstSpiceDouble * arg1, ConstSpiceDouble * arg2, SpiceBoolean value, SpiceChar IN_STRING)"""
    return _cspyce0.repml(arg1, arg2, value, IN_STRING)

def return_():
    r"""return_() -> SpiceBoolean"""
    return _cspyce0.return_()

def shellc(ndim):
    r"""shellc(SpiceInt ndim)"""
    return _cspyce0.shellc(ndim)

def shelld(ndim, array):
    r"""shelld(SpiceInt ndim, SpiceDouble * array)"""
    return _cspyce0.shelld(ndim, array)

def shelli(ndim, array):
    r"""shelli(SpiceInt ndim, SpiceInt * array)"""
    return _cspyce0.shelli(ndim, array)

def spk14a(handle, ncsets, arg3, arg4):
    r"""spk14a(SpiceInt handle, SpiceInt ncsets, ConstSpiceDouble * arg3, ConstSpiceDouble * arg4)"""
    return _cspyce0.spk14a(handle, ncsets, arg3, arg4)

def spk14b(handle, arg2, body, center, arg5, first, last, chbdeg):
    r"""spk14b(SpiceInt handle, ConstSpiceChar * arg2, SpiceInt body, SpiceInt center, ConstSpiceChar * arg5, SpiceDouble first, SpiceDouble last, SpiceInt chbdeg)"""
    return _cspyce0.spk14b(handle, arg2, body, center, arg5, first, last, chbdeg)

def spk14e(handle):
    r"""spk14e(SpiceInt handle)"""
    return _cspyce0.spk14e(handle)

def spkcls(handle):
    r"""spkcls(SpiceInt handle)"""
    return _cspyce0.spkcls(handle)

def spkcpo(arg1, et, arg3, arg4, arg5, obspos, arg7, arg8):
    r"""spkcpo(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceDouble [3] obspos, ConstSpiceChar * arg7, ConstSpiceChar * arg8)"""
    return _cspyce0.spkcpo(arg1, et, arg3, arg4, arg5, obspos, arg7, arg8)

def spkcpo_vector(str1, in11, str2, str3, str4, in21, str5, str6):
    r"""spkcpo_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceDouble * in21, ConstSpiceChar * str5, ConstSpiceChar * str6)"""
    return _cspyce0.spkcpo_vector(str1, in11, str2, str3, str4, in21, str5, str6)

def spkcpt(trgpos, arg2, arg3, et, arg5, arg6, arg7, arg8):
    r"""spkcpt(ConstSpiceDouble [3] trgpos, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceDouble et, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceChar * arg8)"""
    return _cspyce0.spkcpt(trgpos, arg2, arg3, et, arg5, arg6, arg7, arg8)

def spkcpt_vector(in21, str1, str2, in11, str3, str4, str5, str6):
    r"""spkcpt_vector(ConstSpiceDouble * in21, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6)"""
    return _cspyce0.spkcpt_vector(in21, str1, str2, in11, str3, str4, str5, str6)

def spkcvo(arg1, et, arg3, arg4, arg5, obssta, obsepc, arg8, arg9):
    r"""spkcvo(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceDouble [6] obssta, SpiceDouble obsepc, ConstSpiceChar * arg8, ConstSpiceChar * arg9)"""
    return _cspyce0.spkcvo(arg1, et, arg3, arg4, arg5, obssta, obsepc, arg8, arg9)

def spkcvo_vector(str1, in11, str2, str3, str4, in21, in12, str5, str6):
    r"""spkcvo_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceDouble * in21, ConstSpiceDouble * in12, ConstSpiceChar * str5, ConstSpiceChar * str6)"""
    return _cspyce0.spkcvo_vector(str1, in11, str2, str3, str4, in21, in12, str5, str6)

def spkcvt(trgsta, trgepc, arg3, arg4, et, arg6, arg7, arg8, arg9):
    r"""spkcvt(ConstSpiceDouble [6] trgsta, SpiceDouble trgepc, ConstSpiceChar * arg3, ConstSpiceChar * arg4, SpiceDouble et, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceChar * arg8, ConstSpiceChar * arg9)"""
    return _cspyce0.spkcvt(trgsta, trgepc, arg3, arg4, et, arg6, arg7, arg8, arg9)

def spkcvt_vector(in21, in11, str1, str2, in12, str3, str4, str5, str6):
    r"""spkcvt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in12, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6)"""
    return _cspyce0.spkcvt_vector(in21, in11, str1, str2, in12, str3, str4, str5, str6)

def spklef(CONST_STRING):
    r"""spklef(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.spklef(CONST_STRING)

def spkopa(CONST_STRING):
    r"""spkopa(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.spkopa(CONST_STRING)

def spkopn(arg1, arg2, ncomch):
    r"""spkopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt ncomch)"""
    return _cspyce0.spkopn(arg1, arg2, ncomch)

def spkpds(body, center, CONST_STRING, type, first, last):
    r"""spkpds(SpiceInt body, SpiceInt center, ConstSpiceChar * CONST_STRING, SpiceInt type, SpiceDouble first, SpiceDouble last)"""
    return _cspyce0.spkpds(body, center, CONST_STRING, type, first, last)

def spkpvn(handle, descr, et):
    r"""spkpvn(SpiceInt handle, ConstSpiceDouble [5] descr, SpiceDouble et)"""
    return _cspyce0.spkpvn(handle, descr, et)

def spksfs(body, et, idlen, ident):
    r"""spksfs(SpiceInt body, SpiceDouble et, SpiceInt idlen, SpiceChar * ident)"""
    return _cspyce0.spksfs(body, et, idlen, ident)

def spksub(handle, descr, CONST_STRING, begin, end, newh):
    r"""spksub(SpiceInt handle, SpiceDouble [5] descr, ConstSpiceChar * CONST_STRING, SpiceDouble begin, SpiceDouble end, SpiceInt newh)"""
    return _cspyce0.spksub(handle, descr, CONST_STRING, begin, end, newh)

def spkuds(descr):
    r"""spkuds(ConstSpiceDouble [5] descr)"""
    return _cspyce0.spkuds(descr)

def spkuef(handle):
    r"""spkuef(SpiceInt handle)"""
    return _cspyce0.spkuef(handle)

def spkw02(handle, body, center, arg4, first, last, arg7, intlen, n, polydg, IN_ARRAY1, btime):
    r"""spkw02(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceDouble intlen, SpiceInt n, SpiceInt polydg, ConstSpiceDouble * IN_ARRAY1, SpiceDouble btime)"""
    return _cspyce0.spkw02(handle, body, center, arg4, first, last, arg7, intlen, n, polydg, IN_ARRAY1, btime)

def spkw03(handle, body, center, arg4, first, last, arg7, intlen, n, polydg, IN_ARRAY1, btime):
    r"""spkw03(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceDouble intlen, SpiceInt n, SpiceInt polydg, ConstSpiceDouble * IN_ARRAY1, SpiceDouble btime)"""
    return _cspyce0.spkw03(handle, body, center, arg4, first, last, arg7, intlen, n, polydg, IN_ARRAY1, btime)

def spkw05(handle, body, center, arg4, first, last, arg7, gm, n, arg10, arg11):
    r"""spkw05(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceDouble gm, SpiceInt n, ConstSpiceDouble * arg10, ConstSpiceDouble * arg11)"""
    return _cspyce0.spkw05(handle, body, center, arg4, first, last, arg7, gm, n, arg10, arg11)

def spkw08(handle, body, center, arg4, first, last, arg7, degree, n, IN_ARRAY1, begtim, step):
    r"""spkw08(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceInt degree, SpiceInt n, ConstSpiceDouble * IN_ARRAY1, SpiceDouble begtim, SpiceDouble step)"""
    return _cspyce0.spkw08(handle, body, center, arg4, first, last, arg7, degree, n, IN_ARRAY1, begtim, step)

def spkw09(handle, body, center, arg4, first, last, arg7, degree, n, arg10, arg11):
    r"""spkw09(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceInt degree, SpiceInt n, ConstSpiceDouble * arg10, ConstSpiceDouble * arg11)"""
    return _cspyce0.spkw09(handle, body, center, arg4, first, last, arg7, degree, n, arg10, arg11)

def spkw10(handle, body, center, arg4, first, last, arg7, consts, n, arg10, arg11):
    r"""spkw10(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, ConstSpiceDouble [8] consts, SpiceInt n, ConstSpiceDouble * arg10, ConstSpiceDouble * arg11)"""
    return _cspyce0.spkw10(handle, body, center, arg4, first, last, arg7, consts, n, arg10, arg11)

def spkw12(handle, body, center, arg4, first, last, arg7, degree, n, IN_ARRAY1, begtim, step):
    r"""spkw12(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceInt degree, SpiceInt n, ConstSpiceDouble * IN_ARRAY1, SpiceDouble begtim, SpiceDouble step)"""
    return _cspyce0.spkw12(handle, body, center, arg4, first, last, arg7, degree, n, IN_ARRAY1, begtim, step)

def spkw13(handle, body, center, arg4, first, last, arg7, degree, n, arg10, arg11):
    r"""spkw13(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceInt degree, SpiceInt n, ConstSpiceDouble * arg10, ConstSpiceDouble * arg11)"""
    return _cspyce0.spkw13(handle, body, center, arg4, first, last, arg7, degree, n, arg10, arg11)

def spkw15(handle, body, center, arg4, first, last, arg7, epoch, tp, pa, p, ecc, j2flg, pv, gm, j2, radius):
    r"""spkw15(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceDouble epoch, ConstSpiceDouble [3] tp, ConstSpiceDouble [3] pa, SpiceDouble p, SpiceDouble ecc, SpiceDouble j2flg, ConstSpiceDouble [3] pv, SpiceDouble gm, SpiceDouble j2, SpiceDouble radius)"""
    return _cspyce0.spkw15(handle, body, center, arg4, first, last, arg7, epoch, tp, pa, p, ecc, j2flg, pv, gm, j2, radius)

def spkw17(handle, body, center, arg4, first, last, arg7, epoch, eqel, rapol, decpol):
    r"""spkw17(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceDouble epoch, ConstSpiceDouble [9] eqel, SpiceDouble rapol, SpiceDouble decpol)"""
    return _cspyce0.spkw17(handle, body, center, arg4, first, last, arg7, epoch, eqel, rapol, decpol)

def spkw18(handle, subtyp, body, center, frame, first, last, segid, degree, n, packts, epochs):
    r"""spkw18(SpiceInt handle, ConstSpiceChar * subtyp, SpiceInt body, SpiceInt center, ConstSpiceChar * frame, SpiceDouble first, SpiceDouble last, ConstSpiceChar * segid, SpiceInt degree, SpiceInt n, ConstSpiceDouble * packts, ConstSpiceDouble * epochs)"""
    return _cspyce0.spkw18(handle, subtyp, body, center, frame, first, last, segid, degree, n, packts, epochs)

def spkw20(handle, body, center, arg4, first, last, arg7, intlen, n, polydg, IN_ARRAY1, dscale, tscale, initjd, initfr):
    r"""spkw20(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceDouble intlen, SpiceInt n, SpiceInt polydg, ConstSpiceDouble * IN_ARRAY1, SpiceDouble dscale, SpiceDouble tscale, SpiceDouble initjd, SpiceDouble initfr)"""
    return _cspyce0.spkw20(handle, body, center, arg4, first, last, arg7, intlen, n, polydg, IN_ARRAY1, dscale, tscale, initjd, initfr)

def sumad(array):
    r"""sumad(ConstSpiceDouble * array) -> SpiceDouble"""
    return _cspyce0.sumad(array)

def sumai(array):
    r"""sumai(ConstSpiceInt * array) -> SpiceInt"""
    return _cspyce0.sumai(array)

def swpool(CONST_STRING, nnames):
    r"""swpool(ConstSpiceChar * CONST_STRING, SpiceInt nnames)"""
    return _cspyce0.swpool(CONST_STRING, nnames)

def szpool(CONST_STRING):
    r"""szpool(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.szpool(CONST_STRING)

def tangpt(arg1, arg2, et, arg4, arg5, arg6, arg7, arg8, dvec):
    r"""tangpt(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceChar * arg8, ConstSpiceDouble [3] dvec)"""
    return _cspyce0.tangpt(arg1, arg2, et, arg4, arg5, arg6, arg7, arg8, dvec)

def tangpt_vector(str1, str2, in11, str3, str4, str5, str6, str7, in21):
    r"""tangpt_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceChar * str7, ConstSpiceDouble * in21)"""
    return _cspyce0.tangpt_vector(str1, str2, in11, str3, str4, str5, str6, str7, in21)

def tkfram(frcode):
    r"""tkfram(SpiceInt frcode)"""
    return _cspyce0.tkfram(frcode)

def tparch(CONST_STRING):
    r"""tparch(ConstSpiceChar * CONST_STRING)"""
    return _cspyce0.tparch(CONST_STRING)

def trgsep(et, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9):
    r"""trgsep(SpiceDouble et, ConstSpiceChar * arg2, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceChar * arg8, ConstSpiceChar * arg9) -> SpiceDouble"""
    return _cspyce0.trgsep(et, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)

def trgsep_vector(in11, str1, str2, str3, str4, str5, str6, str7, str8):
    r"""trgsep_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceChar * str7, ConstSpiceChar * str8)"""
    return _cspyce0.trgsep_vector(in11, str1, str2, str3, str4, str5, str6, str7, str8)

def twovxf(axdef, indexa, plndef, indexp):
    r"""twovxf(ConstSpiceDouble [6] axdef, SpiceInt indexa, ConstSpiceDouble [6] plndef, SpiceInt indexp)"""
    return _cspyce0.twovxf(axdef, indexa, plndef, indexp)

def twovxf_vector(in21, k1, in22, k2):
    r"""twovxf_vector(ConstSpiceDouble * in21, SpiceInt k1, ConstSpiceDouble * in22, SpiceInt k2)"""
    return _cspyce0.twovxf_vector(in21, k1, in22, k2)

def vprojg(a, b):
    r"""vprojg(ConstSpiceDouble * a, ConstSpiceDouble * b)"""
    return _cspyce0.vprojg(a, b)

def my_vprojg_nomalloc(a, b, ndim2):
    r"""my_vprojg_nomalloc(ConstSpiceDouble * a, ConstSpiceDouble * b, SpiceInt * ndim2)"""
    return _cspyce0.my_vprojg_nomalloc(a, b, ndim2)

def vprojg_vector(in21, in22):
    r"""vprojg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
    return _cspyce0.vprojg_vector(in21, in22)

def wncomd(left, right, n):
    r"""wncomd(SpiceDouble left, SpiceDouble right, int n)"""
    return _cspyce0.wncomd(left, right, n)

def wncond(left, right, n):
    r"""wncond(SpiceDouble left, SpiceDouble right, int n)"""
    return _cspyce0.wncond(left, right, n)

def wndifd(na, nb):
    r"""wndifd(int na, int nb)"""
    return _cspyce0.wndifd(na, nb)

def wnelmd(point, n):
    r"""wnelmd(SpiceDouble point, int n) -> SpiceBoolean"""
    return _cspyce0.wnelmd(point, n)

def wnexpd(left, right, n):
    r"""wnexpd(SpiceDouble left, SpiceDouble right, int n)"""
    return _cspyce0.wnexpd(left, right, n)

def wnextd(side, n):
    r"""wnextd(SpiceChar side, int n)"""
    return _cspyce0.wnextd(side, n)

def wnfild(smlgap, n):
    r"""wnfild(SpiceDouble smlgap, int n)"""
    return _cspyce0.wnfild(smlgap, n)

def wnfltd(smlint, n):
    r"""wnfltd(SpiceDouble smlint, int n)"""
    return _cspyce0.wnfltd(smlint, n)

def wnincd(left, right, n):
    r"""wnincd(SpiceDouble left, SpiceDouble right, int n) -> SpiceBoolean"""
    return _cspyce0.wnincd(left, right, n)

def wninsd(left, right, n):
    r"""wninsd(SpiceDouble left, SpiceDouble right, int n)"""
    return _cspyce0.wninsd(left, right, n)

def wnintd(na, nb):
    r"""wnintd(int na, int nb)"""
    return _cspyce0.wnintd(na, nb)

def wnreld(na, op, nb):
    r"""wnreld(int na, ConstSpiceChar * op, int nb) -> SpiceBoolean"""
    return _cspyce0.wnreld(na, op, nb)

def wnsumd(n):
    r"""wnsumd(int n)"""
    return _cspyce0.wnsumd(n)

def wnunid(na, nb):
    r"""wnunid(int na, int nb)"""
    return _cspyce0.wnunid(na, nb)


