text: # This file was automatically generated by SWIG (http://www.swig.org).
  # Version 3.0.12
  #
  # 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):
      def swig_import_helper():
          import importlib
          pkg = __name__.rpartition('.')[0]
          mname = '.'.join((pkg, '_cspyce0')).lstrip('.')
          try:
              return importlib.import_module(mname)
          except ImportError:
              return importlib.import_module('_cspyce0')
      _cspyce0 = swig_import_helper()
      del swig_import_helper
  elif _swig_python_version_info >= (2, 6, 0):
      def swig_import_helper():
          from os.path import dirname
          import imp
          fp = None
          try:
              fp, pathname, description = imp.find_module('_cspyce0', [dirname(__file__)])
          except ImportError:
              import _cspyce0
              return _cspyce0
          try:
              _mod = imp.load_module('_cspyce0', fp, pathname, description)
          finally:
              if fp is not None:
                  fp.close()
          return _mod
      _cspyce0 = swig_import_helper()
      del swig_import_helper
  else:
      import _cspyce0
  del _swig_python_version_info
  
  try:
      _swig_property = property
  except NameError:
      pass  # Python < 2.2 doesn't have 'property'.
  
  try:
      import builtins as __builtin__
  except ImportError:
      import __builtin__
  
  def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
      if (name == "thisown"):
          return self.this.own(value)
      if (name == "this"):
          if type(value).__name__ == 'SwigPyObject':
              self.__dict__[name] = value
              return
      method = class_type.__swig_setmethods__.get(name, None)
      if method:
          return method(self, value)
      if (not static):
          if _newclass:
              object.__setattr__(self, name, value)
          else:
              self.__dict__[name] = value
      else:
          raise AttributeError("You cannot add attributes to %s" % self)
  
  
  def _swig_setattr(self, class_type, name, value):
      return _swig_setattr_nondynamic(self, class_type, name, value, 0)
  
  
  def _swig_getattr(self, class_type, name):
      if (name == "thisown"):
          return self.this.own()
      method = class_type.__swig_getmethods__.get(name, None)
      if method:
          return method(self)
      raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
  
  
  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,)
  
  try:
      _object = object
      _newclass = 1
  except __builtin__.Exception:
      class _object:
          pass
      _newclass = 0
  
  
  def axisar(axis, angle):
      """axisar(ConstSpiceDouble [3] axis, SpiceDouble angle)"""
      return _cspyce0.axisar(axis, angle)
  
  def axisar_vector(in21, in11):
      """axisar_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11)"""
      return _cspyce0.axisar_vector(in21, in11)
  
  def b1900():
      """b1900() -> SpiceDouble"""
      return _cspyce0.b1900()
  
  def b1950():
      """b1950() -> SpiceDouble"""
      return _cspyce0.b1950()
  
  def bltfrm(frmcls):
      """bltfrm(SpiceInt frmcls)"""
      return _cspyce0.bltfrm(frmcls)
  
  def bodc2n(code):
      """bodc2n(SpiceInt code)"""
      return _cspyce0.bodc2n(code)
  
  def bodc2s(code):
      """bodc2s(SpiceInt code)"""
      return _cspyce0.bodc2s(code)
  
  def boddef(CONST_STRING, code):
      """boddef(ConstSpiceChar * CONST_STRING, SpiceInt code)"""
      return _cspyce0.boddef(CONST_STRING, code)
  
  def bodfnd(body, CONST_STRING):
      """bodfnd(SpiceInt body, ConstSpiceChar * CONST_STRING) -> SpiceBoolean"""
      return _cspyce0.bodfnd(body, CONST_STRING)
  
  def bodn2c(CONST_STRING):
      """bodn2c(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.bodn2c(CONST_STRING)
  
  def bods2c(CONST_STRING):
      """bods2c(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.bods2c(CONST_STRING)
  
  def bodvar(body, CONST_STRING):
      """bodvar(SpiceInt body, ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.bodvar(body, CONST_STRING)
  
  def bodvcd(bodyid, CONST_STRING):
      """bodvcd(SpiceInt bodyid, ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.bodvcd(bodyid, CONST_STRING)
  
  def bodvrd(arg1, arg2):
      """bodvrd(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"""
      return _cspyce0.bodvrd(arg1, arg2)
  
  def ccifrm(frclss, clssid):
      """ccifrm(SpiceInt frclss, SpiceInt clssid)"""
      return _cspyce0.ccifrm(frclss, clssid)
  
  def cgv2el(center, vec1, vec2):
      """cgv2el(ConstSpiceDouble [3] center, ConstSpiceDouble [3] vec1, ConstSpiceDouble [3] vec2)"""
      return _cspyce0.cgv2el(center, vec1, vec2)
  
  def cgv2el_vector(in21, in22, in23):
      """cgv2el_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"""
      return _cspyce0.cgv2el_vector(in21, in22, in23)
  
  def chkin(CONST_STRING):
      """chkin(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.chkin(CONST_STRING)
  
  def chkout(CONST_STRING):
      """chkout(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.chkout(CONST_STRING)
  
  def cidfrm(cent):
      """cidfrm(SpiceInt cent)"""
      return _cspyce0.cidfrm(cent)
  
  def ckcov(ck, idcode, needav, level, tol, timsys):
      """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):
      """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):
      """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):
      """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):
      """ckgpav_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceChar * str1)"""
      return _cspyce0.ckgpav_vector(k1, in11, in12, str1)
  
  def ckobj(ck):
      """ckobj(ConstSpiceChar * ck)"""
      return _cspyce0.ckobj(ck)
  
  def clight():
      """clight() -> SpiceDouble"""
      return _cspyce0.clight()
  
  def clpool():
      """clpool()"""
      return _cspyce0.clpool()
  
  def cnmfrm(cname):
      """cnmfrm(ConstSpiceChar * cname)"""
      return _cspyce0.cnmfrm(cname)
  
  def conics(elts, et):
      """conics(ConstSpiceDouble [8] elts, SpiceDouble et)"""
      return _cspyce0.conics(elts, et)
  
  def conics_vector(in21, in11):
      """conics_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11)"""
      return _cspyce0.conics_vector(in21, in11)
  
  def convrt(x, arg2, arg3):
      """convrt(SpiceDouble x, ConstSpiceChar * arg2, ConstSpiceChar * arg3)"""
      return _cspyce0.convrt(x, arg2, arg3)
  
  def convrt_vector(in11, str1, str2):
      """convrt_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2)"""
      return _cspyce0.convrt_vector(in11, str1, str2)
  
  def cyllat(r, lonc, z):
      """cyllat(SpiceDouble r, SpiceDouble lonc, SpiceDouble z)"""
      return _cspyce0.cyllat(r, lonc, z)
  
  def cyllat_vector(in11, in12, in13):
      """cyllat_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.cyllat_vector(in11, in12, in13)
  
  def cylrec(r, lon, z):
      """cylrec(SpiceDouble r, SpiceDouble lon, SpiceDouble z)"""
      return _cspyce0.cylrec(r, lon, z)
  
  def cylrec_vector(in11, in12, in13):
      """cylrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.cylrec_vector(in11, in12, in13)
  
  def cylsph(r, lonc, z):
      """cylsph(SpiceDouble r, SpiceDouble lonc, SpiceDouble z)"""
      return _cspyce0.cylsph(r, lonc, z)
  
  def cylsph_vector(in11, in12, in13):
      """cylsph_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.cylsph_vector(in11, in12, in13)
  
  def dafbfs(handle):
      """dafbfs(SpiceInt handle)"""
      return _cspyce0.dafbfs(handle)
  
  def dafcls(handle):
      """dafcls(SpiceInt handle)"""
      return _cspyce0.dafcls(handle)
  
  def dafgda(handle, begin, end):
      """dafgda(SpiceInt handle, SpiceInt begin, SpiceInt end)"""
      return _cspyce0.dafgda(handle, begin, end)
  
  def dafgn():
      """dafgn()"""
      return _cspyce0.dafgn()
  
  def dafgs():
      """dafgs()"""
      return _cspyce0.dafgs()
  
  def daffna():
      """daffna()"""
      return _cspyce0.daffna()
  
  def dafopr(CONST_STRING):
      """dafopr(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.dafopr(CONST_STRING)
  
  def dafus(sum, nd, ni):
      """dafus(ConstSpiceDouble [128] sum, SpiceInt nd, SpiceInt ni)"""
      return _cspyce0.dafus(sum, nd, ni)
  
  def dcyldr(x, y, z):
      """dcyldr(SpiceDouble x, SpiceDouble y, SpiceDouble z)"""
      return _cspyce0.dcyldr(x, y, z)
  
  def dcyldr_vector(in11, in12, in13):
      """dcyldr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.dcyldr_vector(in11, in12, in13)
  
  def deltet(epoch, CONST_STRING):
      """deltet(SpiceDouble epoch, ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.deltet(epoch, CONST_STRING)
  
  def deltet_vector(in11, str1):
      """deltet_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1)"""
      return _cspyce0.deltet_vector(in11, str1)
  
  def det(m1):
      """det(ConstSpiceDouble [3][3] m1) -> SpiceDouble"""
      return _cspyce0.det(m1)
  
  def det_vector(in31):
      """det_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.det_vector(in31)
  
  def dgeodr(x, y, z, re, f):
      """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):
      """dgeodr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"""
      return _cspyce0.dgeodr_vector(in11, in12, in13, in14, in15)
  
  def diags2(symmat):
      """diags2(ConstSpiceDouble [2][2] symmat)"""
      return _cspyce0.diags2(symmat)
  
  def diags2_vector(in31):
      """diags2_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.diags2_vector(in31)
  
  def dlatdr(x, y, z):
      """dlatdr(SpiceDouble x, SpiceDouble y, SpiceDouble z)"""
      return _cspyce0.dlatdr(x, y, z)
  
  def dlatdr_vector(in11, in12, in13):
      """dlatdr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.dlatdr_vector(in11, in12, in13)
  
  def dpgrdr(CONST_STRING, x, y, z, re, f):
      """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):
      """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():
      """dpmax() -> SpiceDouble"""
      return _cspyce0.dpmax()
  
  def dpmin():
      """dpmin() -> SpiceDouble"""
      return _cspyce0.dpmin()
  
  def dpr():
      """dpr() -> SpiceDouble"""
      return _cspyce0.dpr()
  
  def drdcyl(r, lon, z):
      """drdcyl(SpiceDouble r, SpiceDouble lon, SpiceDouble z)"""
      return _cspyce0.drdcyl(r, lon, z)
  
  def drdcyl_vector(in11, in12, in13):
      """drdcyl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.drdcyl_vector(in11, in12, in13)
  
  def drdgeo(lon, lat, alt, re, f):
      """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):
      """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):
      """drdlat(SpiceDouble r, SpiceDouble lon, SpiceDouble lat)"""
      return _cspyce0.drdlat(r, lon, lat)
  
  def drdlat_vector(in11, in12, in13):
      """drdlat_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.drdlat_vector(in11, in12, in13)
  
  def drdpgr(CONST_STRING, lon, lat, alt, re, f):
      """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):
      """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):
      """drdsph(SpiceDouble r, SpiceDouble colat, SpiceDouble lon)"""
      return _cspyce0.drdsph(r, colat, lon)
  
  def drdsph_vector(in11, in12, in13):
      """drdsph_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.drdsph_vector(in11, in12, in13)
  
  def dsphdr(x, y, z):
      """dsphdr(SpiceDouble x, SpiceDouble y, SpiceDouble z)"""
      return _cspyce0.dsphdr(x, y, z)
  
  def dsphdr_vector(in11, in12, in13):
      """dsphdr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.dsphdr_vector(in11, in12, in13)
  
  def dtpool(CONST_STRING):
      """dtpool(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.dtpool(CONST_STRING)
  
  def ducrss(s1, s2):
      """ducrss(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2)"""
      return _cspyce0.ducrss(s1, s2)
  
  def ducrss_vector(in21, in22):
      """ducrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.ducrss_vector(in21, in22)
  
  def dvcrss(s1, s2):
      """dvcrss(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2)"""
      return _cspyce0.dvcrss(s1, s2)
  
  def dvcrss_vector(in21, in22):
      """dvcrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.dvcrss_vector(in21, in22)
  
  def dvdot(s1, s2):
      """dvdot(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2) -> SpiceDouble"""
      return _cspyce0.dvdot(s1, s2)
  
  def dvdot_vector(in21, in22):
      """dvdot_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.dvdot_vector(in21, in22)
  
  def dvhat(s1):
      """dvhat(ConstSpiceDouble [6] s1)"""
      return _cspyce0.dvhat(s1)
  
  def dvhat_vector(in21):
      """dvhat_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.dvhat_vector(in21)
  
  def dvnorm(state):
      """dvnorm(ConstSpiceDouble [6] state) -> SpiceDouble"""
      return _cspyce0.dvnorm(state)
  
  def dvnorm_vector(in21):
      """dvnorm_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.dvnorm_vector(in21)
  
  def dvpool(CONST_STRING):
      """dvpool(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.dvpool(CONST_STRING)
  
  def dvsep(s1, s2):
      """dvsep(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2) -> SpiceDouble"""
      return _cspyce0.dvsep(s1, s2)
  
  def dvsep_vector(in21, in22):
      """dvsep_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.dvsep_vector(in21, in22)
  
  def edlimb(a, b, c, viewpt):
      """edlimb(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [3] viewpt)"""
      return _cspyce0.edlimb(a, b, c, viewpt)
  
  def edlimb_vector(in11, in12, in13, in21):
      """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):
      """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):
      """el2cgv(ConstSpiceDouble [NELLIPSE] ellipse)"""
      return _cspyce0.el2cgv(ellipse)
  
  def el2cgv_vector(in21):
      """el2cgv_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.el2cgv_vector(in21)
  
  def eqncpv(et, epoch, eqel, rapol, decpol):
      """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):
      """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):
      """erract(ConstSpiceChar * op, SpiceInt lenout)"""
      return _cspyce0.erract(op, lenout)
  
  def errch(arg1, arg2):
      """errch(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"""
      return _cspyce0.errch(arg1, arg2)
  
  def errdev(CONST_STRING, lenout):
      """errdev(ConstSpiceChar * CONST_STRING, SpiceInt lenout)"""
      return _cspyce0.errdev(CONST_STRING, lenout)
  
  def errdp(CONST_STRING, number):
      """errdp(ConstSpiceChar * CONST_STRING, SpiceDouble number)"""
      return _cspyce0.errdp(CONST_STRING, number)
  
  def errint(CONST_STRING, number):
      """errint(ConstSpiceChar * CONST_STRING, SpiceInt number)"""
      return _cspyce0.errint(CONST_STRING, number)
  
  def errprt(CONST_STRING, lenout):
      """errprt(ConstSpiceChar * CONST_STRING, SpiceInt lenout)"""
      return _cspyce0.errprt(CONST_STRING, lenout)
  
  def et2lst(et, body, lon, ltype):
      """et2lst(SpiceDouble et, SpiceInt body, SpiceDouble lon, ConstSpiceChar * ltype)"""
      return _cspyce0.et2lst(et, body, lon, ltype)
  
  def et2utc(et, CONST_STRING, prec):
      """et2utc(SpiceDouble et, ConstSpiceChar * CONST_STRING, SpiceInt prec)"""
      return _cspyce0.et2utc(et, CONST_STRING, prec)
  
  def etcal(et):
      """etcal(SpiceDouble et)"""
      return _cspyce0.etcal(et)
  
  def eul2m(angle3, angle2, angle1, axis3, axis2, axis1):
      """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):
      """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):
      """eul2xf(ConstSpiceDouble [6] eulang, SpiceInt axisa, SpiceInt axisb, SpiceInt axisc)"""
      return _cspyce0.eul2xf(eulang, axisa, axisb, axisc)
  
  def eul2xf_vector(in21, k1, k2, k3):
      """eul2xf_vector(ConstSpiceDouble * in21, SpiceInt k1, SpiceInt k2, SpiceInt k3)"""
      return _cspyce0.eul2xf_vector(in21, k1, k2, k3)
  
  def expool(CONST_STRING):
      """expool(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.expool(CONST_STRING)
  
  def failed():
      """failed() -> SpiceBoolean"""
      return _cspyce0.failed()
  
  def fovray(inst, raydir, rframe, abcorr, observer, et, visible):
      """fovray(ConstSpiceChar * inst, ConstSpiceDouble [3] raydir, ConstSpiceChar * rframe, ConstSpiceChar * abcorr, ConstSpiceChar * observer, SpiceDouble et, SpiceBoolean * visible)"""
      return _cspyce0.fovray(inst, raydir, rframe, abcorr, observer, et, visible)
  
  def fovray_vector(str1, in21, str2, str3, str4, in11):
      """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, observer, et, visible):
      """fovtrg(ConstSpiceChar * inst, ConstSpiceChar * target, ConstSpiceChar * tshape, ConstSpiceChar * tframe, ConstSpiceChar * abcorr, ConstSpiceChar * observer, SpiceDouble et, SpiceBoolean * visible)"""
      return _cspyce0.fovtrg(inst, target, tshape, tframe, abcorr, observer, et, visible)
  
  def fovtrg_vector(str1, str2, str3, str4, str5, str6, in11):
      """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(xin):
      """frame(SpiceDouble [3] xin)"""
      return _cspyce0.frame(xin)
  
  def frame_vector(in21):
      """frame_vector(SpiceDouble * in21)"""
      return _cspyce0.frame_vector(in21)
  
  def frinfo(frcode):
      """frinfo(SpiceInt frcode)"""
      return _cspyce0.frinfo(frcode)
  
  def frmchg(frame1, frame2, et):
      """frmchg(SpiceInt frame1, SpiceInt frame2, SpiceDouble et)"""
      return _cspyce0.frmchg(frame1, frame2, et)
  
  def frmchg_(frame1, frame2, et, xform):
      """frmchg_(SpiceInt * frame1, SpiceInt * frame2, SpiceDouble * et, SpiceDouble * xform)"""
      return _cspyce0.frmchg_(frame1, frame2, et, xform)
  
  def frmchg_vector(k1, k2, in11):
      """frmchg_vector(SpiceInt k1, SpiceInt k2, ConstSpiceDouble * in11)"""
      return _cspyce0.frmchg_vector(k1, k2, in11)
  
  def frmnam(frcode):
      """frmnam(SpiceInt frcode)"""
      return _cspyce0.frmnam(frcode)
  
  def furnsh(CONST_STRING):
      """furnsh(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.furnsh(CONST_STRING)
  
  def gcpool(CONST_STRING, start):
      """gcpool(ConstSpiceChar * CONST_STRING, SpiceInt start)"""
      return _cspyce0.gcpool(CONST_STRING, start)
  
  def gdpool(CONST_STRING, start):
      """gdpool(ConstSpiceChar * CONST_STRING, SpiceInt start)"""
      return _cspyce0.gdpool(CONST_STRING, start)
  
  def georec(lon, lat, alt, re, f):
      """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):
      """georec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"""
      return _cspyce0.georec_vector(in11, in12, in13, in14, in15)
  
  def getfov(instid):
      """getfov(SpiceInt instid)"""
      return _cspyce0.getfov(instid)
  
  def getmsg(option):
      """getmsg(ConstSpiceChar * option)"""
      return _cspyce0.getmsg(option)
  
  def gipool(CONST_STRING, start):
      """gipool(ConstSpiceChar * CONST_STRING, SpiceInt start)"""
      return _cspyce0.gipool(CONST_STRING, start)
  
  def gnpool(CONST_STRING, start):
      """gnpool(ConstSpiceChar * CONST_STRING, SpiceInt start)"""
      return _cspyce0.gnpool(CONST_STRING, start)
  
  def halfpi():
      """halfpi() -> SpiceDouble"""
      return _cspyce0.halfpi()
  
  def ident():
      """ident()"""
      return _cspyce0.ident()
  
  def illum(arg1, et, arg3, arg4, spoint):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """inedpl(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [NPLANE] plane)"""
      return _cspyce0.inedpl(a, b, c, plane)
  
  def inedpl_vector(in11, in12, in13, in21):
      """inedpl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in21)"""
      return _cspyce0.inedpl_vector(in11, in12, in13, in21)
  
  def inelpl(ellipse, plane):
      """inelpl(ConstSpiceDouble [NELLIPSE] ellipse, ConstSpiceDouble [NPLANE] plane)"""
      return _cspyce0.inelpl(ellipse, plane)
  
  def inelpl_vector(in21, in22):
      """inelpl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.inelpl_vector(in21, in22)
  
  def inrypl(vertex, dir, plane):
      """inrypl(ConstSpiceDouble [3] vertex, ConstSpiceDouble [3] dir, ConstSpiceDouble [NPLANE] plane)"""
      return _cspyce0.inrypl(vertex, dir, plane)
  
  def inrypl_vector(in21, in22, in23):
      """inrypl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"""
      return _cspyce0.inrypl_vector(in21, in22, in23)
  
  def intmax():
      """intmax() -> SpiceInt"""
      return _cspyce0.intmax()
  
  def intmin():
      """intmin() -> SpiceInt"""
      return _cspyce0.intmin()
  
  def invert(m1):
      """invert(ConstSpiceDouble [3][3] m1)"""
      return _cspyce0.invert(m1)
  
  def invert_vector(in31):
      """invert_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.invert_vector(in31)
  
  def invort(m):
      """invort(ConstSpiceDouble [3][3] m)"""
      return _cspyce0.invort(m)
  
  def invort_vector(in31):
      """invort_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.invort_vector(in31)
  
  def isrot(m, ntol, dtol):
      """isrot(ConstSpiceDouble [3][3] m, SpiceDouble ntol, SpiceDouble dtol) -> SpiceBoolean"""
      return _cspyce0.isrot(m, ntol, dtol)
  
  def isrot_vector(in31, in11, in12):
      """isrot_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
      return _cspyce0.isrot_vector(in31, in11, in12)
  
  def j1900():
      """j1900() -> SpiceDouble"""
      return _cspyce0.j1900()
  
  def j1950():
      """j1950() -> SpiceDouble"""
      return _cspyce0.j1950()
  
  def j2000():
      """j2000() -> SpiceDouble"""
      return _cspyce0.j2000()
  
  def j2100():
      """j2100() -> SpiceDouble"""
      return _cspyce0.j2100()
  
  def jyear():
      """jyear() -> SpiceDouble"""
      return _cspyce0.jyear()
  
  def kplfrm(frmcls):
      """kplfrm(SpiceInt frmcls)"""
      return _cspyce0.kplfrm(frmcls)
  
  def latcyl(radius, lon, lat):
      """latcyl(SpiceDouble radius, SpiceDouble lon, SpiceDouble lat)"""
      return _cspyce0.latcyl(radius, lon, lat)
  
  def latcyl_vector(in11, in12, in13):
      """latcyl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.latcyl_vector(in11, in12, in13)
  
  def latrec(radius, longitude, latitude):
      """latrec(SpiceDouble radius, SpiceDouble longitude, SpiceDouble latitude)"""
      return _cspyce0.latrec(radius, longitude, latitude)
  
  def latrec_vector(in11, in12, in13):
      """latrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.latrec_vector(in11, in12, in13)
  
  def latsrf(method, target, et, fixref, lonlat):
      """latsrf(ConstSpiceChar * method, ConstSpiceChar * target, SpiceDouble et, ConstSpiceChar * fixref, ConstSpiceDouble [1][2] lonlat)"""
      return _cspyce0.latsrf(method, target, et, fixref, lonlat)
  
  def latsph(radius, lon, lat):
      """latsph(SpiceDouble radius, SpiceDouble lon, SpiceDouble lat)"""
      return _cspyce0.latsph(radius, lon, lat)
  
  def latsph_vector(in11, in12, in13):
      """latsph_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.latsph_vector(in11, in12, in13)
  
  def ldpool(CONST_STRING):
      """ldpool(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.ldpool(CONST_STRING)
  
  def limbpt(method, target, et, fixref, abcorr, corloc, obsrvr, refvec, rolstp, ncuts, schstp, soltol, maxn):
      """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):
      """lspcn(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3) -> SpiceDouble"""
      return _cspyce0.lspcn(arg1, et, arg3)
  
  def lspcn_vector(str1, in11, str2):
      """lspcn_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2)"""
      return _cspyce0.lspcn_vector(str1, in11, str2)
  
  def ltime(etobs, obs, CONST_STRING, targ):
      """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):
      """ltime_vector(ConstSpiceDouble * in11, SpiceInt k1, ConstSpiceChar * str1, SpiceInt k2)"""
      return _cspyce0.ltime_vector(in11, k1, str1, k2)
  
  def m2eul(rin, axis3, axis2, axis1):
      """m2eul(ConstSpiceDouble [3][3] rin, SpiceInt axis3, SpiceInt axis2, SpiceInt axis1)"""
      return _cspyce0.m2eul(rin, axis3, axis2, axis1)
  
  def m2eul_vector(in31, k1, k2, k3):
      """m2eul_vector(ConstSpiceDouble * in31, SpiceInt k1, SpiceInt k2, SpiceInt k3)"""
      return _cspyce0.m2eul_vector(in31, k1, k2, k3)
  
  def m2q(rin):
      """m2q(ConstSpiceDouble [3][3] rin)"""
      return _cspyce0.m2q(rin)
  
  def m2q_vector(in31):
      """m2q_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.m2q_vector(in31)
  
  def mequ(m1):
      """mequ(ConstSpiceDouble [3][3] m1)"""
      return _cspyce0.mequ(m1)
  
  def mequ_vector(in31):
      """mequ_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.mequ_vector(in31)
  
  def mequg(m1):
      """mequg(ConstSpiceDouble * m1)"""
      return _cspyce0.mequg(m1)
  
  def my_mequg_nomalloc(m1, mout, nr_out, nc_out):
      """my_mequg_nomalloc(ConstSpiceDouble * m1, SpiceDouble * mout, int * nr_out, int * nc_out)"""
      return _cspyce0.my_mequg_nomalloc(m1, mout, nr_out, nc_out)
  
  def mequg_vector(in31):
      """mequg_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.mequg_vector(in31)
  
  def mtxm(m1, m2):
      """mtxm(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3][3] m2)"""
      return _cspyce0.mtxm(m1, m2)
  
  def mtxm_vector(in31, in32):
      """mtxm_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
      return _cspyce0.mtxm_vector(in31, in32)
  
  def mtxmg(m1, m2):
      """mtxmg(ConstSpiceDouble * m1, ConstSpiceDouble * m2)"""
      return _cspyce0.mtxmg(m1, m2)
  
  def my_mtxmg_nomalloc(m1, m2, m3, nr3, nc3):
      """my_mtxmg_nomalloc(ConstSpiceDouble * m1, ConstSpiceDouble * m2, SpiceDouble * m3, int * nr3, int * nc3)"""
      return _cspyce0.my_mtxmg_nomalloc(m1, m2, m3, nr3, nc3)
  
  def mtxmg_vector(in31, in32):
      """mtxmg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
      return _cspyce0.mtxmg_vector(in31, in32)
  
  def mtxv(m1, vin):
      """mtxv(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3] vin)"""
      return _cspyce0.mtxv(m1, vin)
  
  def mtxv_vector(in31, in21):
      """mtxv_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"""
      return _cspyce0.mtxv_vector(in31, in21)
  
  def mtxvg(m1, v2):
      """mtxvg(ConstSpiceDouble * m1, ConstSpiceDouble * v2)"""
      return _cspyce0.mtxvg(m1, v2)
  
  def my_mtxvg_nomalloc(m1, v2, v3, nr3):
      """my_mtxvg_nomalloc(ConstSpiceDouble * m1, ConstSpiceDouble * v2, SpiceDouble * v3, int * nr3)"""
      return _cspyce0.my_mtxvg_nomalloc(m1, v2, v3, nr3)
  
  def mtxvg_vector(in31, in21):
      """mtxvg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"""
      return _cspyce0.mtxvg_vector(in31, in21)
  
  def mxm(m1, m2):
      """mxm(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3][3] m2)"""
      return _cspyce0.mxm(m1, m2)
  
  def mxm_vector(in31, in32):
      """mxm_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
      return _cspyce0.mxm_vector(in31, in32)
  
  def mxmg(m1, m2):
      """mxmg(ConstSpiceDouble * m1, ConstSpiceDouble * m2)"""
      return _cspyce0.mxmg(m1, m2)
  
  def my_mxmg_nomalloc(m1, m2, m3, nr3, nc3):
      """my_mxmg_nomalloc(ConstSpiceDouble * m1, ConstSpiceDouble * m2, SpiceDouble * m3, int * nr3, int * nc3)"""
      return _cspyce0.my_mxmg_nomalloc(m1, m2, m3, nr3, nc3)
  
  def mxmg_vector(in31, in32):
      """mxmg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
      return _cspyce0.mxmg_vector(in31, in32)
  
  def mxmt(m1, m2):
      """mxmt(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3][3] m2)"""
      return _cspyce0.mxmt(m1, m2)
  
  def mxmt_vector(in31, in32):
      """mxmt_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
      return _cspyce0.mxmt_vector(in31, in32)
  
  def mxmtg(m1, m2):
      """mxmtg(ConstSpiceDouble * m1, ConstSpiceDouble * m2)"""
      return _cspyce0.mxmtg(m1, m2)
  
  def my_mxmtg_nomalloc(m1, m2, m3, nr3, nc3):
      """my_mxmtg_nomalloc(ConstSpiceDouble * m1, ConstSpiceDouble * m2, SpiceDouble * m3, int * nr3, int * nc3)"""
      return _cspyce0.my_mxmtg_nomalloc(m1, m2, m3, nr3, nc3)
  
  def mxmtg_vector(in31, in32):
      """mxmtg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"""
      return _cspyce0.mxmtg_vector(in31, in32)
  
  def mxv(m1, vin):
      """mxv(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3] vin)"""
      return _cspyce0.mxv(m1, vin)
  
  def mxv_vector(in31, in21):
      """mxv_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"""
      return _cspyce0.mxv_vector(in31, in21)
  
  def mxvg(m1, v2):
      """mxvg(ConstSpiceDouble * m1, ConstSpiceDouble * v2)"""
      return _cspyce0.mxvg(m1, v2)
  
  def my_mxvg_nomalloc(m1, v2, v3, nr3):
      """my_mxvg_nomalloc(ConstSpiceDouble * m1, ConstSpiceDouble * v2, SpiceDouble * v3, int * nr3)"""
      return _cspyce0.my_mxvg_nomalloc(m1, v2, v3, nr3)
  
  def mxvg_vector(in31, in21):
      """mxvg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"""
      return _cspyce0.mxvg_vector(in31, in21)
  
  def namfrm(CONST_STRING):
      """namfrm(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.namfrm(CONST_STRING)
  
  def nearpt(positn, a, b, c):
      """nearpt(ConstSpiceDouble [3] positn, SpiceDouble a, SpiceDouble b, SpiceDouble c)"""
      return _cspyce0.nearpt(positn, a, b, c)
  
  def nearpt_vector(in21, in11, in12, in13):
      """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):
      """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):
      """npedln_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.npedln_vector(in11, in12, in13, in21, in22)
  
  def npelpt(point, ellipse):
      """npelpt(ConstSpiceDouble [3] point, ConstSpiceDouble [NELLIPSE] ellipse)"""
      return _cspyce0.npelpt(point, ellipse)
  
  def npelpt_vector(in21, in22):
      """npelpt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.npelpt_vector(in21, in22)
  
  def nplnpt(linpt, lindir, point):
      """nplnpt(ConstSpiceDouble [3] linpt, ConstSpiceDouble [3] lindir, ConstSpiceDouble [3] point)"""
      return _cspyce0.nplnpt(linpt, lindir, point)
  
  def nplnpt_vector(in21, in22, in23):
      """nplnpt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"""
      return _cspyce0.nplnpt_vector(in21, in22, in23)
  
  def nvc2pl(normal, constant):
      """nvc2pl(ConstSpiceDouble [3] normal, SpiceDouble constant)"""
      return _cspyce0.nvc2pl(normal, constant)
  
  def nvc2pl_vector(in21, in11):
      """nvc2pl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11)"""
      return _cspyce0.nvc2pl_vector(in21, in11)
  
  def nvp2pl(normal, point):
      """nvp2pl(ConstSpiceDouble [3] normal, ConstSpiceDouble [3] point)"""
      return _cspyce0.nvp2pl(normal, point)
  
  def nvp2pl_vector(in21, in22):
      """nvp2pl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.nvp2pl_vector(in21, in22)
  
  def occult(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, et):
      """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):
      """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):
      """oscelt(ConstSpiceDouble [6] state, SpiceDouble et, SpiceDouble mu)"""
      return _cspyce0.oscelt(state, et, mu)
  
  def oscelt_vector(in21, in11, in12):
      """oscelt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
      return _cspyce0.oscelt_vector(in21, in11, in12)
  
  def oscltx(state, et, mu):
      """oscltx(ConstSpiceDouble [6] state, SpiceDouble et, SpiceDouble mu)"""
      return _cspyce0.oscltx(state, et, mu)
  
  def oscltx_vector(in21, in11, in12):
      """oscltx_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
      return _cspyce0.oscltx_vector(in21, in11, in12)
  
  def pckcov(pck, idcode):
      """pckcov(ConstSpiceChar * pck, SpiceInt idcode)"""
      return _cspyce0.pckcov(pck, idcode)
  
  def pckfrm(pck):
      """pckfrm(ConstSpiceChar * pck)"""
      return _cspyce0.pckfrm(pck)
  
  def pcpool(CONST_STRING, n):
      """pcpool(ConstSpiceChar * CONST_STRING, SpiceInt n)"""
      return _cspyce0.pcpool(CONST_STRING, n)
  
  def pdpool(CONST_STRING, n):
      """pdpool(ConstSpiceChar * CONST_STRING, SpiceInt n)"""
      return _cspyce0.pdpool(CONST_STRING, n)
  
  def pgrrec(CONST_STRING, lon, lat, alt, re, f):
      """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):
      """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):
      """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):
      """phaseq_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4)"""
      return _cspyce0.phaseq_vector(in11, str1, str2, str3, str4)
  
  def pi():
      """pi() -> SpiceDouble"""
      return _cspyce0.pi()
  
  def pipool(CONST_STRING, n):
      """pipool(ConstSpiceChar * CONST_STRING, SpiceInt n)"""
      return _cspyce0.pipool(CONST_STRING, n)
  
  def pjelpl(elin, plane):
      """pjelpl(ConstSpiceDouble [NELLIPSE] elin, ConstSpiceDouble [NPLANE] plane)"""
      return _cspyce0.pjelpl(elin, plane)
  
  def pjelpl_vector(in21, in22):
      """pjelpl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.pjelpl_vector(in21, in22)
  
  def pltar(nv, np):
      """pltar(SpiceInt nv, SpiceInt np) -> SpiceDouble"""
      return _cspyce0.pltar(nv, np)
  
  def pltexp(iverts, delta):
      """pltexp(ConstSpiceDouble [3][3] iverts, SpiceDouble delta)"""
      return _cspyce0.pltexp(iverts, delta)
  
  def pltexp_vector(in31, in11):
      """pltexp_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11)"""
      return _cspyce0.pltexp_vector(in31, in11)
  
  def pltnp(point, v1, v2, v3):
      """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):
      """pltnp_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23, ConstSpiceDouble * in24)"""
      return _cspyce0.pltnp_vector(in21, in22, in23, in24)
  
  def pltvol(nv, np):
      """pltvol(SpiceInt nv, SpiceInt np) -> SpiceDouble"""
      return _cspyce0.pltvol(nv, np)
  
  def pl2nvc(plane):
      """pl2nvc(ConstSpiceDouble [NPLANE] plane)"""
      return _cspyce0.pl2nvc(plane)
  
  def pl2nvc_vector(in21):
      """pl2nvc_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.pl2nvc_vector(in21)
  
  def pl2nvp(plane):
      """pl2nvp(ConstSpiceDouble [NPLANE] plane)"""
      return _cspyce0.pl2nvp(plane)
  
  def pl2nvp_vector(in21):
      """pl2nvp_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.pl2nvp_vector(in21)
  
  def pl2psv(plane):
      """pl2psv(ConstSpiceDouble [NPLANE] plane)"""
      return _cspyce0.pl2psv(plane)
  
  def pl2psv_vector(in21):
      """pl2psv_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.pl2psv_vector(in21)
  
  def prop2b(gm, pvinit, dt):
      """prop2b(SpiceDouble gm, ConstSpiceDouble [6] pvinit, SpiceDouble dt)"""
      return _cspyce0.prop2b(gm, pvinit, dt)
  
  def prop2b_vector(in11, in21, in12):
      """prop2b_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in12)"""
      return _cspyce0.prop2b_vector(in11, in21, in12)
  
  def psv2pl(point, span1, span2):
      """psv2pl(ConstSpiceDouble [3] point, ConstSpiceDouble [3] span1, ConstSpiceDouble [3] span2)"""
      return _cspyce0.psv2pl(point, span1, span2)
  
  def psv2pl_vector(in21, in22, in23):
      """psv2pl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"""
      return _cspyce0.psv2pl_vector(in21, in22, in23)
  
  def pxform(arg1, arg2, et):
      """pxform(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et)"""
      return _cspyce0.pxform(arg1, arg2, et)
  
  def pxform_vector(str1, str2, in11):
      """pxform_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11)"""
      return _cspyce0.pxform_vector(str1, str2, in11)
  
  def pxfrm2(arg1, arg2, etfrom, et2):
      """pxfrm2(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble etfrom, SpiceDouble et2)"""
      return _cspyce0.pxfrm2(arg1, arg2, etfrom, et2)
  
  def pxfrm2_vector(str1, str2, in11, in12):
      """pxfrm2_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
      return _cspyce0.pxfrm2_vector(str1, str2, in11, in12)
  
  def q2m(qin):
      """q2m(ConstSpiceDouble [4] qin)"""
      return _cspyce0.q2m(qin)
  
  def q2m_vector(in21):
      """q2m_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.q2m_vector(in21)
  
  def qcktrc():
      """qcktrc()"""
      return _cspyce0.qcktrc()
  
  def qdq2av(qin, dq):
      """qdq2av(ConstSpiceDouble [4] qin, ConstSpiceDouble [4] dq)"""
      return _cspyce0.qdq2av(qin, dq)
  
  def qdq2av_vector(in21, in22):
      """qdq2av_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.qdq2av_vector(in21, in22)
  
  def qxq(q1, q2):
      """qxq(ConstSpiceDouble [4] q1, ConstSpiceDouble [4] q2)"""
      return _cspyce0.qxq(q1, q2)
  
  def qxq_vector(in21, in22):
      """qxq_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.qxq_vector(in21, in22)
  
  def radrec(range, ra, dec):
      """radrec(SpiceDouble range, SpiceDouble ra, SpiceDouble dec)"""
      return _cspyce0.radrec(range, ra, dec)
  
  def radrec_vector(in11, in12, in13):
      """radrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.radrec_vector(in11, in12, in13)
  
  def rav2xf(rot, av):
      """rav2xf(ConstSpiceDouble [3][3] rot, ConstSpiceDouble [3] av)"""
      return _cspyce0.rav2xf(rot, av)
  
  def rav2xf_vector(in31, in21):
      """rav2xf_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"""
      return _cspyce0.rav2xf_vector(in31, in21)
  
  def raxisa(matrix):
      """raxisa(ConstSpiceDouble [3][3] matrix)"""
      return _cspyce0.raxisa(matrix)
  
  def raxisa_vector(in31):
      """raxisa_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.raxisa_vector(in31)
  
  def reccyl(rectan1):
      """reccyl(ConstSpiceDouble [3] rectan1)"""
      return _cspyce0.reccyl(rectan1)
  
  def reccyl_vector(in21):
      """reccyl_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.reccyl_vector(in21)
  
  def recgeo(rectan1, re, f):
      """recgeo(ConstSpiceDouble [3] rectan1, SpiceDouble re, SpiceDouble f)"""
      return _cspyce0.recgeo(rectan1, re, f)
  
  def recgeo_vector(in21, in11, in12):
      """recgeo_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
      return _cspyce0.recgeo_vector(in21, in11, in12)
  
  def reclat(rectan1):
      """reclat(ConstSpiceDouble [3] rectan1)"""
      return _cspyce0.reclat(rectan1)
  
  def reclat_vector(in21):
      """reclat_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.reclat_vector(in21)
  
  def recpgr(CONST_STRING, rectan1, re, f):
      """recpgr(ConstSpiceChar * CONST_STRING, SpiceDouble [3] rectan1, SpiceDouble re, SpiceDouble f)"""
      return _cspyce0.recpgr(CONST_STRING, rectan1, re, f)
  
  def recpgr_vector(str1, in21, in11, in12):
      """recpgr_vector(ConstSpiceChar * str1, SpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
      return _cspyce0.recpgr_vector(str1, in21, in11, in12)
  
  def recrad(rectan):
      """recrad(ConstSpiceDouble [3] rectan)"""
      return _cspyce0.recrad(rectan)
  
  def recrad_vector(in21):
      """recrad_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.recrad_vector(in21)
  
  def recsph(rectan):
      """recsph(ConstSpiceDouble [3] rectan)"""
      return _cspyce0.recsph(rectan)
  
  def recsph_vector(in21):
      """recsph_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.recsph_vector(in21)
  
  def refchg(frame1, frame2, et):
      """refchg(SpiceInt frame1, SpiceInt frame2, SpiceDouble et)"""
      return _cspyce0.refchg(frame1, frame2, et)
  
  def refchg_(frame1, frame2, et, rotate):
      """refchg_(SpiceInt * frame1, SpiceInt * frame2, SpiceDouble * et, SpiceDouble * rotate)"""
      return _cspyce0.refchg_(frame1, frame2, et, rotate)
  
  def refchg_vector(k1, k2, in11):
      """refchg_vector(SpiceInt k1, SpiceInt k2, ConstSpiceDouble * in11)"""
      return _cspyce0.refchg_vector(k1, k2, in11)
  
  def repmc(arg1, arg2, arg3):
      """repmc(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3)"""
      return _cspyce0.repmc(arg1, arg2, arg3)
  
  def repmct(arg1, arg2, value, IN_STRING):
      """repmct(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt value, SpiceChar IN_STRING)"""
      return _cspyce0.repmct(arg1, arg2, value, IN_STRING)
  
  def repmd(arg1, arg2, value, sigdig):
      """repmd(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble value, SpiceInt sigdig)"""
      return _cspyce0.repmd(arg1, arg2, value, sigdig)
  
  def repmf(arg1, arg2, value, sigdig, format):
      """repmf(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble value, SpiceInt sigdig, SpiceChar format)"""
      return _cspyce0.repmf(arg1, arg2, value, sigdig, format)
  
  def repmi(arg1, arg2, value):
      """repmi(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt value)"""
      return _cspyce0.repmi(arg1, arg2, value)
  
  def repmot(arg1, arg2, value, IN_STRING):
      """repmot(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt value, SpiceChar IN_STRING)"""
      return _cspyce0.repmot(arg1, arg2, value, IN_STRING)
  
  def reset():
      """reset()"""
      return _cspyce0.reset()
  
  def rotate(angle, iaxis):
      """rotate(SpiceDouble angle, SpiceInt iaxis)"""
      return _cspyce0.rotate(angle, iaxis)
  
  def rotate_vector(in11, k1):
      """rotate_vector(ConstSpiceDouble * in11, SpiceInt k1)"""
      return _cspyce0.rotate_vector(in11, k1)
  
  def rotmat(m1, angle, iaxis):
      """rotmat(ConstSpiceDouble [3][3] m1, SpiceDouble angle, SpiceInt iaxis)"""
      return _cspyce0.rotmat(m1, angle, iaxis)
  
  def rotmat_vector(in31, in11, k1):
      """rotmat_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11, SpiceInt k1)"""
      return _cspyce0.rotmat_vector(in31, in11, k1)
  
  def rotvec(v1, angle, iaxis):
      """rotvec(ConstSpiceDouble [3] v1, SpiceDouble angle, SpiceInt iaxis)"""
      return _cspyce0.rotvec(v1, angle, iaxis)
  
  def rotvec_vector(in21, in11, k1):
      """rotvec_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, SpiceInt k1)"""
      return _cspyce0.rotvec_vector(in21, in11, k1)
  
  def rpd():
      """rpd() -> SpiceDouble"""
      return _cspyce0.rpd()
  
  def rquad(a, b, c):
      """rquad(SpiceDouble a, SpiceDouble b, SpiceDouble c)"""
      return _cspyce0.rquad(a, b, c)
  
  def rquad_vector(in11, in12, in13):
      """rquad_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.rquad_vector(in11, in12, in13)
  
  def saelgv(vec1, vec2):
      """saelgv(ConstSpiceDouble [3] vec1, ConstSpiceDouble [3] vec2)"""
      return _cspyce0.saelgv(vec1, vec2)
  
  def saelgv_vector(in21, in22):
      """saelgv_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.saelgv_vector(in21, in22)
  
  def scdecd(sc, sclkdp):
      """scdecd(SpiceInt sc, SpiceDouble sclkdp)"""
      return _cspyce0.scdecd(sc, sclkdp)
  
  def sce2c(sc, et):
      """sce2c(SpiceInt sc, SpiceDouble et)"""
      return _cspyce0.sce2c(sc, et)
  
  def sce2c_vector(k1, in11):
      """sce2c_vector(SpiceInt k1, ConstSpiceDouble * in11)"""
      return _cspyce0.sce2c_vector(k1, in11)
  
  def sce2s(sc, et):
      """sce2s(SpiceInt sc, SpiceDouble et)"""
      return _cspyce0.sce2s(sc, et)
  
  def sce2t(sc, et):
      """sce2t(SpiceInt sc, SpiceDouble et)"""
      return _cspyce0.sce2t(sc, et)
  
  def sce2t_vector(k1, in11):
      """sce2t_vector(SpiceInt k1, ConstSpiceDouble * in11)"""
      return _cspyce0.sce2t_vector(k1, in11)
  
  def scencd(sc, CONST_STRING):
      """scencd(SpiceInt sc, ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.scencd(sc, CONST_STRING)
  
  def scfmt(sc, ticks):
      """scfmt(SpiceInt sc, SpiceDouble ticks)"""
      return _cspyce0.scfmt(sc, ticks)
  
  def scpart(sc):
      """scpart(SpiceInt sc)"""
      return _cspyce0.scpart(sc)
  
  def scs2e(sc, CONST_STRING):
      """scs2e(SpiceInt sc, ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.scs2e(sc, CONST_STRING)
  
  def sct2e(sc, sclkdp):
      """sct2e(SpiceInt sc, SpiceDouble sclkdp)"""
      return _cspyce0.sct2e(sc, sclkdp)
  
  def sct2e_vector(k1, in11):
      """sct2e_vector(SpiceInt k1, ConstSpiceDouble * in11)"""
      return _cspyce0.sct2e_vector(k1, in11)
  
  def sctiks(sc, CONST_STRING):
      """sctiks(SpiceInt sc, ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.sctiks(sc, CONST_STRING)
  
  def setmsg(message):
      """setmsg(ConstSpiceChar * message)"""
      return _cspyce0.setmsg(message)
  
  def sigerr(CONST_STRING):
      """sigerr(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.sigerr(CONST_STRING)
  
  def sincpt(arg1, arg2, et, arg4, arg5, arg6, arg7, dvec):
      """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):
      """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():
      """spd() -> SpiceDouble"""
      return _cspyce0.spd()
  
  def sphcyl(radius, colat, slon):
      """sphcyl(SpiceDouble radius, SpiceDouble colat, SpiceDouble slon)"""
      return _cspyce0.sphcyl(radius, colat, slon)
  
  def sphcyl_vector(in11, in12, in13):
      """sphcyl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.sphcyl_vector(in11, in12, in13)
  
  def sphlat(r, colat, lons):
      """sphlat(SpiceDouble r, SpiceDouble colat, SpiceDouble lons)"""
      return _cspyce0.sphlat(r, colat, lons)
  
  def sphlat_vector(in11, in12, in13):
      """sphlat_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.sphlat_vector(in11, in12, in13)
  
  def sphrec(r, colat, lon):
      """sphrec(SpiceDouble r, SpiceDouble colat, SpiceDouble lon)"""
      return _cspyce0.sphrec(r, colat, lon)
  
  def sphrec_vector(in11, in12, in13):
      """sphrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.sphrec_vector(in11, in12, in13)
  
  def spkacs(targ, et, arg3, arg4, obs):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """spkcov(ConstSpiceChar * spk, SpiceInt idcode)"""
      return _cspyce0.spkcov(spk, idcode)
  
  def spkez(targ, et, arg3, arg4, obs):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """spkltc_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in21)"""
      return _cspyce0.spkltc_vector(k1, in11, str1, str2, in21)
  
  def spkobj(spk):
      """spkobj(ConstSpiceChar * spk)"""
      return _cspyce0.spkobj(spk)
  
  def spkpos(arg1, et, arg3, arg4, arg5):
      """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):
      """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):
      """spkssb(SpiceInt targ, SpiceDouble et, ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.spkssb(targ, et, CONST_STRING)
  
  def spkssb_vector(k1, in11, str1):
      """spkssb_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1)"""
      return _cspyce0.spkssb_vector(k1, in11, str1)
  
  def srfc2s(code, bodyid):
      """srfc2s(SpiceInt code, SpiceInt bodyid)"""
      return _cspyce0.srfc2s(code, bodyid)
  
  def srfcss(code, CONST_STRING):
      """srfcss(SpiceInt code, ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.srfcss(code, CONST_STRING)
  
  def srfnrm(method, target, et, fixref, npts):
      """srfnrm(ConstSpiceChar * method, ConstSpiceChar * target, SpiceDouble et, ConstSpiceChar * fixref, SpiceInt npts)"""
      return _cspyce0.srfnrm(method, target, et, fixref, npts)
  
  def srfrec(body, longitude, latitude):
      """srfrec(SpiceInt body, SpiceDouble longitude, SpiceDouble latitude)"""
      return _cspyce0.srfrec(body, longitude, latitude)
  
  def srfrec_vector(k1, in11, in12):
      """srfrec_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"""
      return _cspyce0.srfrec_vector(k1, in11, in12)
  
  def srfs2c(arg1, arg2):
      """srfs2c(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"""
      return _cspyce0.srfs2c(arg1, arg2)
  
  def srfscc(CONST_STRING, body_id):
      """srfscc(ConstSpiceChar * CONST_STRING, SpiceInt body_id)"""
      return _cspyce0.srfscc(CONST_STRING, body_id)
  
  def srfxpt(arg1, arg2, et, arg4, arg5, arg6, dvec):
      """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):
      """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):
      """stcf01(ConstSpiceChar * catnam, SpiceDouble westra, SpiceDouble eastra, SpiceDouble sthdec, SpiceDouble nthdec)"""
      return _cspyce0.stcf01(catnam, westra, eastra, sthdec, nthdec)
  
  def stcg01(index):
      """stcg01(SpiceInt index)"""
      return _cspyce0.stcg01(index)
  
  def stcl01(catfnm):
      """stcl01(ConstSpiceChar * catfnm)"""
      return _cspyce0.stcl01(catfnm)
  
  def stelab(pobj, vobs):
      """stelab(ConstSpiceDouble [3] pobj, ConstSpiceDouble [3] vobs)"""
      return _cspyce0.stelab(pobj, vobs)
  
  def stelab_vector(in21, in22):
      """stelab_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.stelab_vector(in21, in22)
  
  def stlabx(pobj, vobs):
      """stlabx(ConstSpiceDouble [3] pobj, ConstSpiceDouble [3] vobs)"""
      return _cspyce0.stlabx(pobj, vobs)
  
  def stlabx_vector(in21, in22):
      """stlabx_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.stlabx_vector(in21, in22)
  
  def stpool(item, nth, contin):
      """stpool(ConstSpiceChar * item, SpiceInt nth, ConstSpiceChar * contin)"""
      return _cspyce0.stpool(item, nth, contin)
  
  def str2et(CONST_STRING):
      """str2et(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.str2et(CONST_STRING)
  
  def subpnt(arg1, arg2, et, arg4, arg5, arg6):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """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):
      """surfnm(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [3] point)"""
      return _cspyce0.surfnm(a, b, c, point)
  
  def surfpt(positn, u, a, b, c):
      """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):
      """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):
      """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):
      """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):
      """sxform(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et)"""
      return _cspyce0.sxform(arg1, arg2, et)
  
  def sxform_vector(str1, str2, in11):
      """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):
      """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):
      """timdef(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt lenout)"""
      return _cspyce0.timdef(arg1, arg2, lenout)
  
  def timout(et, CONST_STRING):
      """timout(SpiceDouble et, ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.timout(et, CONST_STRING)
  
  def tipbod(CONST_STRING, body, et):
      """tipbod(ConstSpiceChar * CONST_STRING, SpiceInt body, SpiceDouble et)"""
      return _cspyce0.tipbod(CONST_STRING, body, et)
  
  def tipbod_vector(str1, k1, in11):
      """tipbod_vector(ConstSpiceChar * str1, SpiceInt k1, ConstSpiceDouble * in11)"""
      return _cspyce0.tipbod_vector(str1, k1, in11)
  
  def tisbod(CONST_STRING, body, et):
      """tisbod(ConstSpiceChar * CONST_STRING, SpiceInt body, SpiceDouble et)"""
      return _cspyce0.tisbod(CONST_STRING, body, et)
  
  def tisbod_vector(str1, k1, in11):
      """tisbod_vector(ConstSpiceChar * str1, SpiceInt k1, ConstSpiceDouble * in11)"""
      return _cspyce0.tisbod_vector(str1, k1, in11)
  
  def tkvrsn(CONST_STRING):
      """tkvrsn(ConstSpiceChar * CONST_STRING) -> char *"""
      return _cspyce0.tkvrsn(CONST_STRING)
  
  def tparse(string):
      """tparse(ConstSpiceChar * string)"""
      return _cspyce0.tparse(string)
  
  def tpictr(sample):
      """tpictr(ConstSpiceChar * sample)"""
      return _cspyce0.tpictr(sample)
  
  def trace(matrix):
      """trace(ConstSpiceDouble [3][3] matrix) -> SpiceDouble"""
      return _cspyce0.trace(matrix)
  
  def trace_vector(in31):
      """trace_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.trace_vector(in31)
  
  def trcoff():
      """trcoff()"""
      return _cspyce0.trcoff()
  
  def trcdep():
      """trcdep()"""
      return _cspyce0.trcdep()
  
  def trcnam(index):
      """trcnam(SpiceInt index)"""
      return _cspyce0.trcnam(index)
  
  def tsetyr(year):
      """tsetyr(SpiceInt year)"""
      return _cspyce0.tsetyr(year)
  
  def twopi():
      """twopi() -> SpiceDouble"""
      return _cspyce0.twopi()
  
  def twovec(axdef, indexa, plndef, indexp):
      """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):
      """twovec_vector(ConstSpiceDouble * in21, SpiceInt k1, ConstSpiceDouble * in22, SpiceInt k2)"""
      return _cspyce0.twovec_vector(in21, k1, in22, k2)
  
  def tyear():
      """tyear() -> SpiceDouble"""
      return _cspyce0.tyear()
  
  def ucrss(v1, v2):
      """ucrss(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"""
      return _cspyce0.ucrss(v1, v2)
  
  def ucrss_vector(in21, in22):
      """ucrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.ucrss_vector(in21, in22)
  
  def unitim(epoch, arg2, arg3):
      """unitim(SpiceDouble epoch, ConstSpiceChar * arg2, ConstSpiceChar * arg3) -> SpiceDouble"""
      return _cspyce0.unitim(epoch, arg2, arg3)
  
  def unitim_vector(in11, str1, str2):
      """unitim_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2)"""
      return _cspyce0.unitim_vector(in11, str1, str2)
  
  def unload(CONST_STRING):
      """unload(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.unload(CONST_STRING)
  
  def unorm(v1):
      """unorm(ConstSpiceDouble [3] v1)"""
      return _cspyce0.unorm(v1)
  
  def unorm_vector(in21):
      """unorm_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.unorm_vector(in21)
  
  def unormg(v1):
      """unormg(ConstSpiceDouble * v1)"""
      return _cspyce0.unormg(v1)
  
  def my_unormg_nomalloc(v1, v2, nd2):
      """my_unormg_nomalloc(ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"""
      return _cspyce0.my_unormg_nomalloc(v1, v2, nd2)
  
  def unormg_vector(in21):
      """unormg_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.unormg_vector(in21)
  
  def utc2et(CONST_STRING):
      """utc2et(ConstSpiceChar * CONST_STRING)"""
      return _cspyce0.utc2et(CONST_STRING)
  
  def vadd(v1, v2):
      """vadd(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"""
      return _cspyce0.vadd(v1, v2)
  
  def vadd_vector(in21, in22):
      """vadd_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vadd_vector(in21, in22)
  
  def vaddg(v1, v2):
      """vaddg(ConstSpiceDouble * v1, ConstSpiceDouble * v2)"""
      return _cspyce0.vaddg(v1, v2)
  
  def my_vaddg_nomalloc(v1, v2, v3, nd3):
      """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):
      """vaddg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vaddg_vector(in21, in22)
  
  def vcrss(v1, v2):
      """vcrss(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"""
      return _cspyce0.vcrss(v1, v2)
  
  def vcrss_vector(in21, in22):
      """vcrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vcrss_vector(in21, in22)
  
  def vdist(v1, v2):
      """vdist(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"""
      return _cspyce0.vdist(v1, v2)
  
  def vdist_vector(in21, in22):
      """vdist_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vdist_vector(in21, in22)
  
  def vdistg(v1, v2):
      """vdistg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"""
      return _cspyce0.vdistg(v1, v2)
  
  def vdistg_vector(in21, in22):
      """vdistg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vdistg_vector(in21, in22)
  
  def vdot(v1, v2):
      """vdot(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"""
      return _cspyce0.vdot(v1, v2)
  
  def vdot_vector(in21, in22):
      """vdot_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vdot_vector(in21, in22)
  
  def vdotg(v1, v2):
      """vdotg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"""
      return _cspyce0.vdotg(v1, v2)
  
  def vdotg_vector(in21, in22):
      """vdotg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vdotg_vector(in21, in22)
  
  def vequ(vin):
      """vequ(ConstSpiceDouble [3] vin)"""
      return _cspyce0.vequ(vin)
  
  def vequ_vector(in21):
      """vequ_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.vequ_vector(in21)
  
  def vequg(v1):
      """vequg(ConstSpiceDouble * v1)"""
      return _cspyce0.vequg(v1)
  
  def my_vequg_nomalloc(v1, v2, nd2):
      """my_vequg_nomalloc(ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"""
      return _cspyce0.my_vequg_nomalloc(v1, v2, nd2)
  
  def vequg_vector(in21):
      """vequg_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.vequg_vector(in21)
  
  def vhat(v1):
      """vhat(ConstSpiceDouble [3] v1)"""
      return _cspyce0.vhat(v1)
  
  def vhat_vector(in21):
      """vhat_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.vhat_vector(in21)
  
  def vhatg(v1):
      """vhatg(ConstSpiceDouble * v1)"""
      return _cspyce0.vhatg(v1)
  
  def my_vhatg_nomalloc(v1, v2, nd2):
      """my_vhatg_nomalloc(ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"""
      return _cspyce0.my_vhatg_nomalloc(v1, v2, nd2)
  
  def vhatg_vector(in21):
      """vhatg_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.vhatg_vector(in21)
  
  def vlcom3(a, v1, b, v2, c, v3):
      """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):
      """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):
      """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):
      """vlcom_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in12, ConstSpiceDouble * in22)"""
      return _cspyce0.vlcom_vector(in11, in21, in12, in22)
  
  def vlcomg(a, v1, b, v2):
      """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):
      """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):
      """vlcomg_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in12, ConstSpiceDouble * in22)"""
      return _cspyce0.vlcomg_vector(in11, in21, in12, in22)
  
  def vminug(v1):
      """vminug(ConstSpiceDouble * v1)"""
      return _cspyce0.vminug(v1)
  
  def my_vminug_nomalloc(v1, v2, nd2):
      """my_vminug_nomalloc(ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"""
      return _cspyce0.my_vminug_nomalloc(v1, v2, nd2)
  
  def vminug_vector(in21):
      """vminug_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.vminug_vector(in21)
  
  def vminus(v1):
      """vminus(ConstSpiceDouble [3] v1)"""
      return _cspyce0.vminus(v1)
  
  def vminus_vector(in21):
      """vminus_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.vminus_vector(in21)
  
  def vnorm(v1):
      """vnorm(ConstSpiceDouble [3] v1) -> SpiceDouble"""
      return _cspyce0.vnorm(v1)
  
  def vnorm_vector(in21):
      """vnorm_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.vnorm_vector(in21)
  
  def vnormg(v1):
      """vnormg(ConstSpiceDouble * v1) -> SpiceDouble"""
      return _cspyce0.vnormg(v1)
  
  def vnormg_vector(in21):
      """vnormg_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.vnormg_vector(in21)
  
  def vpack(x, y, z):
      """vpack(SpiceDouble x, SpiceDouble y, SpiceDouble z)"""
      return _cspyce0.vpack(x, y, z)
  
  def vpack_vector(in11, in12, in13):
      """vpack_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.vpack_vector(in11, in12, in13)
  
  def vperp(a, b):
      """vperp(ConstSpiceDouble [3] a, ConstSpiceDouble [3] b)"""
      return _cspyce0.vperp(a, b)
  
  def vperp_vector(in21, in22):
      """vperp_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vperp_vector(in21, in22)
  
  def vprjp(vin, plane):
      """vprjp(ConstSpiceDouble [3] vin, ConstSpiceDouble [NPLANE] plane)"""
      return _cspyce0.vprjp(vin, plane)
  
  def vprjp_vector(in21, in22):
      """vprjp_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vprjp_vector(in21, in22)
  
  def vprjpi(vin, projpl, invpl):
      """vprjpi(ConstSpiceDouble [3] vin, ConstSpiceDouble [NPLANE] projpl, ConstSpiceDouble [NPLANE] invpl)"""
      return _cspyce0.vprjpi(vin, projpl, invpl)
  
  def vprjpi_vector(in21, in22, in23):
      """vprjpi_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"""
      return _cspyce0.vprjpi_vector(in21, in22, in23)
  
  def vproj(a, b):
      """vproj(ConstSpiceDouble [3] a, ConstSpiceDouble [3] b)"""
      return _cspyce0.vproj(a, b)
  
  def vproj_vector(in21, in22):
      """vproj_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vproj_vector(in21, in22)
  
  def vrel(v1, v2):
      """vrel(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"""
      return _cspyce0.vrel(v1, v2)
  
  def vrel_vector(in21, in22):
      """vrel_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vrel_vector(in21, in22)
  
  def vrelg(v1, v2):
      """vrelg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"""
      return _cspyce0.vrelg(v1, v2)
  
  def vrelg_vector(in21, in22):
      """vrelg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vrelg_vector(in21, in22)
  
  def vrotv(v, axis, theta):
      """vrotv(ConstSpiceDouble [3] v, ConstSpiceDouble [3] axis, SpiceDouble theta)"""
      return _cspyce0.vrotv(v, axis, theta)
  
  def vrotv_vector(in21, in22, in11):
      """vrotv_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"""
      return _cspyce0.vrotv_vector(in21, in22, in11)
  
  def vscl(s, v1):
      """vscl(SpiceDouble s, ConstSpiceDouble [3] v1)"""
      return _cspyce0.vscl(s, v1)
  
  def vscl_vector(in11, in21):
      """vscl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21)"""
      return _cspyce0.vscl_vector(in11, in21)
  
  def vsclg(s, v1):
      """vsclg(SpiceDouble s, ConstSpiceDouble * v1)"""
      return _cspyce0.vsclg(s, v1)
  
  def my_vsclg_nomalloc(s, v1, v2, nd2):
      """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):
      """vsclg_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21)"""
      return _cspyce0.vsclg_vector(in11, in21)
  
  def vsep(v1, v2):
      """vsep(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"""
      return _cspyce0.vsep(v1, v2)
  
  def vsep_vector(in21, in22):
      """vsep_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vsep_vector(in21, in22)
  
  def vsepg(v1, v2):
      """vsepg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"""
      return _cspyce0.vsepg(v1, v2)
  
  def vsepg_vector(in21, in22):
      """vsepg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vsepg_vector(in21, in22)
  
  def vsub(v1, v2):
      """vsub(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"""
      return _cspyce0.vsub(v1, v2)
  
  def vsub_vector(in21, in22):
      """vsub_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vsub_vector(in21, in22)
  
  def vsubg(v1, v2):
      """vsubg(ConstSpiceDouble * v1, ConstSpiceDouble * v2)"""
      return _cspyce0.vsubg(v1, v2)
  
  def my_vsubg_nomalloc(v1, v2, v3, nd3):
      """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):
      """vsubg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"""
      return _cspyce0.vsubg_vector(in21, in22)
  
  def vtmv(v1, matrix, v2):
      """vtmv(ConstSpiceDouble [3] v1, ConstSpiceDouble [3][3] matrix, ConstSpiceDouble [3] v2) -> SpiceDouble"""
      return _cspyce0.vtmv(v1, matrix, v2)
  
  def vtmv_vector(in21, in31, in22):
      """vtmv_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in31, ConstSpiceDouble * in22)"""
      return _cspyce0.vtmv_vector(in21, in31, in22)
  
  def vtmvg(v1, matrix, v2):
      """vtmvg(ConstSpiceDouble * v1, ConstSpiceDouble * matrix, ConstSpiceDouble * v2) -> SpiceDouble"""
      return _cspyce0.vtmvg(v1, matrix, v2)
  
  def vtmvg_vector(in21, in31, in22):
      """vtmvg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in31, ConstSpiceDouble * in22)"""
      return _cspyce0.vtmvg_vector(in21, in31, in22)
  
  def vupack(v):
      """vupack(ConstSpiceDouble [3] v)"""
      return _cspyce0.vupack(v)
  
  def vupack_vector(in21):
      """vupack_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.vupack_vector(in21)
  
  def vzero(v):
      """vzero(ConstSpiceDouble [3] v) -> SpiceBoolean"""
      return _cspyce0.vzero(v)
  
  def vzero_vector(in21):
      """vzero_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.vzero_vector(in21)
  
  def vzerog(v):
      """vzerog(ConstSpiceDouble * v) -> SpiceBoolean"""
      return _cspyce0.vzerog(v)
  
  def vzerog_vector(in21):
      """vzerog_vector(ConstSpiceDouble * in21)"""
      return _cspyce0.vzerog_vector(in21)
  
  def xf2eul(xform, axisa, axisb, axisc):
      """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):
      """xf2eul_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"""
      return _cspyce0.xf2eul_vector(in31, in11, in12, in13)
  
  def xf2rav(xform):
      """xf2rav(ConstSpiceDouble [6][6] xform)"""
      return _cspyce0.xf2rav(xform)
  
  def xf2rav_vector(in31):
      """xf2rav_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.xf2rav_vector(in31)
  
  def xfmsta(input_state, arg2, arg3, arg4):
      """xfmsta(ConstSpiceDouble [6] input_state, ConstSpiceChar * arg2, ConstSpiceChar * arg3, ConstSpiceChar * arg4)"""
      return _cspyce0.xfmsta(input_state, arg2, arg3, arg4)
  
  def xfmsta_vector(in21, str1, str2, str3):
      """xfmsta_vector(ConstSpiceDouble * in21, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3)"""
      return _cspyce0.xfmsta_vector(in21, str1, str2, str3)
  
  def xpose6(m1):
      """xpose6(ConstSpiceDouble [6][6] m1)"""
      return _cspyce0.xpose6(m1)
  
  def xpose6_vector(in31):
      """xpose6_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.xpose6_vector(in31)
  
  def xpose(m1):
      """xpose(ConstSpiceDouble [3][3] m1)"""
      return _cspyce0.xpose(m1)
  
  def xpose_vector(in31):
      """xpose_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.xpose_vector(in31)
  
  def xposeg(matrix):
      """xposeg(ConstSpiceDouble * matrix)"""
      return _cspyce0.xposeg(matrix)
  
  def my_xposeg_nomalloc(matrix, xposem, nrow1, ncol1):
      """my_xposeg_nomalloc(ConstSpiceDouble * matrix, SpiceDouble * xposem, int * nrow1, int * ncol1)"""
      return _cspyce0.my_xposeg_nomalloc(matrix, xposem, nrow1, ncol1)
  
  def xposeg_vector(in31):
      """xposeg_vector(ConstSpiceDouble * in31)"""
      return _cspyce0.xposeg_vector(in31)
  # This file is compatible with both classic and new-style classes.
  
  
  